예제 #1
0
파일: LED3.c 프로젝트: napzZztar/Courses
void main() {
     DDRA = 0x02;
     DDRB = 0x04;
     DDRC = 0X08;
     DDRD = 0X16;
     
     while(1){
          PORTA = 0x02;
          Delay_ms(1000);
          allOff();
          Delay_ms(500);
          PORTB = 0x04;
          Delay_ms(1000);
          allOff();
          Delay_ms(500);
          PORTC = 0x08;
          Delay_ms(1000);
          allOff();
          Delay_ms(500);
          PORTD = 0x16;
          Delay_ms(1000);
          allOff();
          Delay_ms(500);
     }
}
void drawCrossed()
{
  //
  // Seqeuentially turns on all the LEDs in a row with a brief delay between each
  //
  for (int i = 0; i <= 7; ++i)
  {
    allOff();
    SensorValue[LED1 + i] = 1;
    SensorValue[LED1 + (7 - i)] = 1;
    if (i == 3)
      i += 2;
    wait1Msec(75);
  }

  for (int i = 1; i <= 7; ++i)
  {
    allOff();
    SensorValue[LED1 + i] = 1;
    SensorValue[LED1 + (7 - i)] = 1;
    if (i == 3)
      i += 2;
    wait1Msec(75);
  }
}
예제 #3
0
////////////////////////////////////////////////////////////////////////////////
// Checks the LED state variable and performs current led pattern
// 0 Off, 1 Rain; 2 Light Rain, 3 Forgotten
void LED::continueState(){

	// If the led state has changed turn off all
	// lights prior to lighting the new pattern
	if(ledState != lastState){
		// changedLocation();
		allOff();
	}

	switch (ledState){
		// 
		case 0:
			allOff();
			break;
		case 1:
			lightRain();
			break;
		case 2:
			rain();
			break;
		case 3:
			heavyRain(); //Change to Heavy rain, will need to create that function
			break;
		case 4:
			forgotten();
			break;
	}

	// Save the last state of the led
	lastState = ledState;
}
예제 #4
0
static void heat_iteration(struct brew_task *bt)
{
    int ii = 0;
    display_status();

    // kick off reading the temp
    vTaskEnterCritical();
    DS1820Init();
    DS1820Skip();
    DS1820Convert();
    vTaskExitCritical();

    // 1 second delay, run heat according to the duty cycle
    for (ii = 0; ii < 100; ii++)
    {
	if (ds1820_get_temperature() < heat_target &&
	    ii <= heat_duty_cycle &&
	    level_hit_heat() == 1) // check the element is covered
	{
	    outputOn(SSR);
	}
	else
	{
	    heat_target_reached = test_had_reached_target();
	    allOff();
	}
	vTaskDelay(10); // wait for the conversion to happen
    }

    vTaskEnterCritical();
    DS1820ReadTemp();
    vTaskExitCritical();
    heat_keep_temperature();
}
예제 #5
0
int main()
{
    // Setup wiringPi
    if (wiringPiSetup() == -1) {
        exit(1);
    }

    // Register signal handler
    signal(SIGINT, signalHandler);

    // Setup all the pins to use OUTPUT mode
    setPinModes(OUTPUT);

    allOff();

    // Open a midi port, connect to through port also
    midi_open();

    // Process events forever
    while (true) {
        midi_process(midi_read());
    }
    
    return -1;
}
예제 #6
0
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
  //setup hardware
    init(); // setzen der varibalen für bus in mainconfig

  //create UI
    ui->setupUi(this);
    //timer for clock
    timer_clock = new QTimer(this);
    connect(timer_clock, SIGNAL(timeout()), this, SLOT(time_update()));
    timer_clock->start(1000);//check every second for new time
    //initial reading
    time_update();

  //start main threads
    sThread = new steuerungThreadLicht(this);
    mThread = new ModelThreadLicht(this);
    Ueberwachung = new thread_Ueberwachung(this, sThread);
    sThread->start();
    mThread->start();
    Ueberwachung->start();
    //communication ui->sThread
    connect(this, SIGNAL(allOff()), sThread, SLOT(allOFF()));
    connect(this, SIGNAL(TeenkreisLichtOn()), sThread, SLOT(teenLichtOn()));
    connect(this, SIGNAL(JugendLichtOn()), sThread, SLOT(jugendLichtON()));
}
GuiEditBoundaryConditions::GuiEditBoundaryConditions()
{
  connect(m_Ui.pushButtonAdd, SIGNAL(clicked()), this, SLOT(addVol()));
  connect(m_Ui.pushButtonDelete, SIGNAL(clicked()), this, SLOT(delVol()));
  connect(m_Ui.pushButtonAddBoundaryType, SIGNAL(clicked()), this, SLOT(addBoundaryType()));
  connect(m_Ui.pushButtonDeleteBoundaryType, SIGNAL(clicked()), this, SLOT(deleteBoundaryType()));
  connect(m_Ui.listWidgetBoundaryType, SIGNAL(itemSelectionChanged()), this, SLOT(changePhysicalValues()));
  connect(m_Ui.pushButton_AddProcess, SIGNAL(clicked()), this, SLOT(addProcess()));
  connect(m_Ui.pushButton_RemoveProcess, SIGNAL(clicked()), this, SLOT(deleteProcess()));
  connect(m_Ui.pushButton_ImportHostFile, SIGNAL(clicked()), this, SLOT(importHostFile()));
  connect(m_Ui.pushButton_ExportHostFile, SIGNAL(clicked()), this, SLOT(exportHostFile()));
  connect(m_Ui.pushButtonAllA, SIGNAL(clicked()), this, SLOT(allA()));
  connect(m_Ui.pushButtonAllB, SIGNAL(clicked()), this, SLOT(allB()));
  connect(m_Ui.pushButtonAllOff, SIGNAL(clicked()), this, SLOT(allOff()));

  setupSolvers();
  loadMpiParameters();

  m_BcMap = NULL;
  delegate = new GuiVolumeDelegate();
  delegate->setFirstCol(3);

  //set initial tab
  m_Ui.tabWidget->setCurrentIndex(0);
}
예제 #8
0
void midi_process(snd_seq_event_t *ev)
{

    // If this event is a PGMCHANGE type, it's a request to map a channel to an instrument
    if (ev->type == SND_SEQ_EVENT_PGMCHANGE) {
        //printf("PGMCHANGE: channel %2d, %5d, %5d\n", ev->data.control.channel, ev->data.control.param,  ev->data.control.value);

        // Clear pins state, this is probably the beginning of a new song
        allOff();
    }

    // If the event is SND_SEQ_EVENT_BOUNCE, then maybe this is an interrupt?
    if (ev->type == SND_SEQ_EVENT_BOUNCE) {
        allOff();
    }

    if (channelActive == ev->data.control.channel) {
        // Note on/off event
        if (ev->type == SND_SEQ_EVENT_NOTEON) {

            // When pinActive is -1, we're playing the first note
            if (-1 == pinActive) {
                pinActive = 0;
            } else {
                // First turn off the current pin
                printf("Turning off pin %d\n", pinActive);
                pinOff(pinActive);

                // Increment pinActive
                printf("Incrementing pinActive\n");
                pinActive++;

                // Reset to zero if we're above the number of pins
                if (pinActive >= TOTAL_PINS) {
                    printf("Resetting pinActive to zero\n");
                    pinActive = 0;
                }
            }

            // Turn on the next pin
            printf("Turning on pin %d\n", pinActive);
            pinOn(pinActive);
        }
    }

    snd_seq_free_event(ev);
}
void FlashableWidget::reset()
{
    oneByOneIndex_ = 0;
    vSelectedHalve_.clear();
    vFirstHalve_.clear();
    vSecondHalve_.clear();
    allOff();
}
예제 #10
0
// Set digital output pins
HVRelays::HVRelays() {
	pinMode(RELAY1, OUTPUT);
	pinMode(RELAY2, OUTPUT);
	pinMode(RELAY3, OUTPUT);
	pinMode(RELAY4, OUTPUT);
	pinMode(RELAY5, OUTPUT);
	pinMode(RELAY6, OUTPUT);
	allOff(); // Make sure everything is off to start
}
void Flash()
{
  //
  // Briefly flashes all the LEDs
  //
  allOn();
  wait1Msec(150);
  allOff();
  wait1Msec(150);
}
예제 #12
0
bool OCGs::optContentIsVisible( Object *dictRef )
{
  Object dictObj;
  Dict *dict;
  Object dictType;
  Object ocg;
  Object policy;
  bool result = true;
  dictRef->fetch( m_xref, &dictObj );
  if ( ! dictObj.isDict() ) {
    error(-1, "Unexpected oc reference target: %i", dictObj.getType() );
    dictObj.free();
    return result;
  }
  dict = dictObj.getDict();
  // printf("checking if optContent is visible\n");
  dict->lookup("Type", &dictType);
  if (dictType.isName("OCMD")) {
    // If we supported Visibility Expressions, we'd check
    // for a VE entry, and then call out to the parser here...
    // printf("found OCMD dict\n");
    dict->lookup("P", &policy);
    dict->lookupNF("OCGs", &ocg);
    if (ocg.isArray()) {
      if (policy.isName("AllOn")) {
	result = allOn( ocg.getArray() );
      } else if (policy.isName("AllOff")) {
	result = allOff( ocg.getArray() );
      } else if (policy.isName("AnyOff")) {
	result = anyOff( ocg.getArray() );
      } else if ( (!policy.isName()) || (policy.isName("AnyOn") ) ) {
	// this is the default
	result = anyOn( ocg.getArray() );
      }
    } else if (ocg.isRef()) {
      OptionalContentGroup* oc = findOcgByRef( ocg.getRef() );      
      if ( !oc || oc->getState() == OptionalContentGroup::Off ) {
	result = false;
      } else {
	result = true ;
      }
    }
    ocg.free();
    policy.free();
  } else if ( dictType.isName("OCG") ) {
    OptionalContentGroup* oc = findOcgByRef( dictRef->getRef() );
    if ( !oc || oc->getState() == OptionalContentGroup::Off ) {
      result=false;
    }
  }
  dictType.free();
  dictObj.free();
  // printf("visibility: %s\n", result? "on" : "off");
  return result;
}
void drawRight()
{
  //
  // Seqeuentially turns on all the LEDs in a row with a brief delay between each
  //
  allOff();
  for (nLED = LED8; nLED >= LED1; --nLED)
  {
    wait1Msec(100);
    SensorValue[nLED] = 1;
  }
  wait1Msec(400);
}
예제 #14
0
////////////////////////////////////////////////////////////////////////////////
// Error LED Pattern
void LED::error(){
	
	allOff();

	int d = 250;

	for(int i=0; i<=4; i++){
		redToggle(HIGH);
		delay(d);
		redToggle(LOW);
		delay(d);
	}
}
예제 #15
0
static void _heat_start(struct brew_task *bt)
{
    allOff();

    // kick off reading the temp
    vTaskEnterCritical();
    DS1820Init();
    DS1820Skip();
    DS1820Convert();
    vTaskExitCritical();

    vTaskDelay(1000);

    vTaskEnterCritical();
    DS1820ReadTemp();
    vTaskExitCritical();    

    // make sure we have consistent readings on the level probes
    level_wait_for_steady_readings();
}
void LedsSimulator::setOffColor(QColor color)
{
    m_offColor = color;
    allOff();
    updateGL();
}
예제 #17
0
void FL7Dl::show(const int dig, int num) {
	if (_on) {
	PORTC &= ~(1<<dig);
	int n = 0;
	switch (dig) {
		case 3:
		PORTB |= _yellow << 2;
		n+=(_yellow)?250/delay:0;
		break;
		case 2:
		PORTB |= _green << 2;
		n+=(_green)? 250/delay :0;
		break;
		case 1:
		PORTB |= _ticker << 2;
		n+=(_ticker)? 250/delay :0;
		break;
		case 0:
		PORTB |= _alarm << 2;
		n+=(_alarm) ? 250/delay :0;
		break;
	}
	switch (num) {
		case 0:
		PORTD |= B11111000;
		PORTB |= B00000001;
		n += 6 * 250/delay;
		break;
		case 1:
		PORTD |= B00110000;
		n += 1 * 250/delay;
		break;
		case 2:
		PORTD |= B11011000;
		PORTB |= B00000010;
		n += 5 * 250/delay;
		break;
		case 3:
		PORTD |= B01111000;
		PORTB |= B00000010;
		n += 5 * 250/delay;
		break;
		case 4:
		PORTD |= B00110000;
		PORTB |= B00000011;
		n += 4 * 250/delay;
		break;
		case 5:
		PORTD |= B01101000;
		PORTB |= B00000011;
		n += 5 * 250/delay;
		break;
		case 6:
		PORTD |= B11101000;
		PORTB |= B00000011;
		n += 7 * 250/delay;
		break;
		case 7:
		PORTD |= B00111000;
		n += 3 * 250/delay;
		break;
		case 8:
		PORTD |= B11111000;
		PORTB |= B00000011;
		n += 7 * 250/delay;
		break;
		case 9:
		PORTD |= B01111000;
		PORTB |= B00000011;
		n += 6 * 250/delay;
		break;
		default:
		PORTB |= B00000010;
		n += 1 * 250/delay;
		break;
	}
	delayMicroseconds(n*delay/(5*500/delay));
	allOff();
	}
}
예제 #18
0
void FL7Dl::showString(char * str) {
	char str2[4] = {0xFF, 0xFF, 0xFF, 0xFF};
	switch (strlen(str)) {
		case 4:
		str2[0] = str[3];
		case 3:
		str2[1] = str[2];
		case 2:
		str2[2] = str[1];
		case 1:
		str2[3] = str[0];
		break;
	}
	for (int i = 3; i >= 0; i--) {
		PORTC &= ~(1<<i);
		switch (str2[3-i]) {
			case 'a':
			PORTD |= B10111000;
			PORTB |= B00000011;
			break;
			case 'b':
			PORTD |= B11100000;
			PORTB |= B00000011;
			break;
			case 'c':
			PORTD |= B11000000;
			PORTB |= B00000010;
			break;
			case 'd':
			PORTD |= B11110000;
			PORTB |= B00000010;
			break;
			case 'e':
			PORTD |= B11001000;
			PORTB |= B00000011;
			break;
			case 'f':
			PORTD |= B10001000;
			PORTB |= B00000011;
			break;
			case 'g':
			PORTD |= B01111000;
			PORTB |= B00000011;
			break;
			case 'h':
			PORTD |= B10100000;
			PORTB |= B00000011;
			break;
			case 'i':
			PORTD |= B00100000;
			break;
			case 'j':
			PORTD |= B11110000;
			break;
			case 'l':
			PORTD |= B11000000;
			PORTB |= B00000001;
			break;
			case 'n':
			PORTD |= B10100000;
			PORTB |= B00000010;
			break;
			case 'o':
			PORTD |= B11100000;
			PORTB |= B00000010;
			break;
			case 'p':
			PORTD |= B10011000;
			PORTB |= B00000011;
			break;
			case 'q':
			PORTD |= B00111000;
			PORTB |= B00000011;
			break;
			case 'r':
			PORTD |= B10000000;
			PORTB |= B00000010;
			break;
			case 's':
			PORTD |= B01101000;
			PORTB |= B00000011;
			break;
			case 't':
			PORTD |= B11000000;
			PORTB |= B00000011;
			break;
			case 'u':
			PORTD |= B11110000;
			PORTB |= B00000001;
			break;
			case 'v':
			PORTD |= B11100000;
			break;
			case 'y':
			PORTD |= B01110000;
			PORTB |= B00000011;
			break;
			case 'z':
			PORTD |= B11011000;
			PORTB |= B00000010;
			break;
			case 0xFF:
			allOff();
			default:
			PORTB |= B00000010;
			break;
		}
		delayMicroseconds(delay);
		allOff();
	}
}
예제 #19
0
void _heat_stop(struct brew_task *bt)
{
    allOff();
}