示例#1
0
void DHT::begin(void) {
// set up the pins!
	pinMode(_pin, INPUT);
	digitalWrite(_pin, HIGH);
	_lastreadtime = 0;
}
示例#2
0
int main(void)
{
	init();

	// proceed depending on the bootloader version
	if( Utils.getBootVersion() >= 'E')
	{
		pinMode(RTC_SLEEP, OUTPUT);
		digitalWrite(RTC_SLEEP, HIGH);
	}
	
	// Check OTA EEPROM flag and mark flag in Waspmote 
	// Control Register if corresponds to
	if( Utils.readEEPROM(0x01) == 0x01 )
	{
		// set register flag
		WaspRegister |= REG_OTA;
		
		// clear eeprom flag
		eeprom_write_byte((unsigned char *) 0x01, 0x00);
	}
	
	delay(3);	
	if( WaspRegister & REG_SX )
	{	
		delay(3);	
		// Powering the module
		pinMode(XBEE_PW,OUTPUT);
		delay(3);
		digitalWrite(XBEE_PW,HIGH);
		delay(3);
		//Configure the MISO, MOSI, CS, SPCR.
		SPI.begin();
		delay(3);
		//Set Most significant bit first
		SPI.setBitOrder(MSBFIRST);
		delay(3);
		//Divide the clock frequency
		SPI.setClockDivider(SPI_CLOCK_DIV2);
		delay(3);
		//Set data mode
		SPI.setDataMode(SPI_MODE0);		
		delay(3);
		//finish
		SPI.end();		
		delay(3);
		// disable all SPI slaves 
		SPI.setSPISlave(ALL_DESELECTED);	
		delay(3);
		// Powering the module
		pinMode(XBEE_PW,OUTPUT);
		digitalWrite(XBEE_PW,LOW);	
		delay(3);
	}	
	
	delay(3);	
	// get serial id
	_serial_id = Utils.readSerialID();
	
	// set random seed
	srand(_serial_id);
	
	setup();
    
	for (;;) {
		loop();

	}
        
	return 0;
}
示例#3
0
// Main arduino loop.
void loop() {
    short      v;
    byte       t;
    int        p;
    rov_servo *s;
    if (!is_waiting && Serial.available() > 32) {
        Serial.write(OP_SHOULDWAIT);
        is_waiting = true;
        return;
    } else if (is_waiting && Serial.available() < 16) {
        Serial.write(OP_SHOULDSTART);
        is_waiting = false;
        return;
    } else if (Serial.available() > 0) {
        switch(Serial.read()) {
        case OP_SERVO_WRITE:
            while(!Serial.available());
            p = Serial.read();
            while(!Serial.available());
            v = Serial.read();
            if (s = lookup_servo(p)) { // Find the servo object on this pin.
                s->s.write(v);
            }
            break;
        case OP_DIGITAL_ON:
            while (!Serial.available());
            digitalWrite(Serial.read(),HIGH);
            break;
        case OP_DIGITAL_OFF:
            while (!Serial.available());
            digitalWrite(Serial.read(),LOW);
            break;
        case OP_DIGITAL_READ:
            while(!Serial.available());
            v = (digitalRead(Serial.read()) == HIGH) ? 1 : 0;
            Serial.write((uint8_t*) &v,2);
            break;
        case OP_ANALOG_WRITE:
            while (!Serial.available());
            p = Serial.read();
            while (!Serial.available());
            v = Serial.read();
            analogWrite(p,v);
            break;
        case OP_ANALOG_READ:
            while (!Serial.available());
            v = analogRead(Serial.read());
            Serial.write((uint8_t*) &v,2);
            break;
        case OP_SET_PINSTATE:
            while (!Serial.available());
            t = Serial.read();
            p = t & 0x3f;  // Get the pin number.
            if (s = lookup_servo(p)) { // Detach any servos on this pin.
                s->s.detach();
                s->p = -1;
            }
            t = (t & 0xc0) >> 6;
            if (t == ROV_SERVO) {
                for (v = 0; v < SERVOC; v++) {
                    if (servov[v].p == -1) { // Find a free servo.
                        s = &servov[v];
                        s->p = p;
                        s->s.attach(p,1000,2000);
                        s->s.write(90);
                        break;
                    }
                }
            } else if (t == INPUT_PULLUP) {
                pinMode(p,INPUT_PULLUP);
            } else {
                pinMode(p,(t) ? OUTPUT : INPUT);
            }
            break;
        }
    }
}
示例#4
0
void setup_distance_sensor() {
    pinMode(TRIG_PIN, OUTPUT);
    digitalWrite(TRIG_PIN, LOW);
    pinMode(ECHO_PIN, INPUT);
}
void Adafruit_SSD1306::begin(uint8_t vccstate, uint8_t i2caddr, bool reset) {
    _vccstate = vccstate;
    _i2caddr = i2caddr;

    // set pin directions
    if (sid != -1) {
        pinMode(dc, OUTPUT);
        pinMode(cs, OUTPUT);
        csport      = portOutputRegister(digitalPinToPort(cs));
        cspinmask   = digitalPinToBitMask(cs);
        dcport      = portOutputRegister(digitalPinToPort(dc));
        dcpinmask   = digitalPinToBitMask(dc);
        if (!hwSPI) {
            // set pins for software-SPI
            pinMode(sid, OUTPUT);
            pinMode(sclk, OUTPUT);
            clkport     = portOutputRegister(digitalPinToPort(sclk));
            clkpinmask  = digitalPinToBitMask(sclk);
            mosiport    = portOutputRegister(digitalPinToPort(sid));
            mosipinmask = digitalPinToBitMask(sid);
        }
        if (hwSPI) {
            SPI.begin ();
//#ifdef __SAM3X8E__
            SPI.setClockDivider (9); // 9.3 MHz
//#else
//     SPI.setClockDivider (SPI_CLOCK_DIV2); // 8 MHz
//#endif
        }
    }
    else
    {
        // I2C Init
        HWIRE.begin();

#ifdef __SAM3X8E__
        // Force 400 KHz I2C, rawr! (Uses pins 20, 21 for SDA, SCL)
        TWI1->TWI_CWGR = 0;
        TWI1->TWI_CWGR = ((VARIANT_MCK / (2 * 400000)) - 4) * 0x101;
#endif
    }

    if (reset) {
        // Setup reset pin direction (used by both SPI and I2C)
        pinMode(rst, OUTPUT);
        digitalWrite(rst, HIGH);
        // VDD (3.3V) goes high at start, lets just chill for a ms
        delay(1);
        // bring reset low
        digitalWrite(rst, LOW);
        // wait 10ms
        delay(10);
        // bring out of reset
        digitalWrite(rst, HIGH);
        // turn on VCC (9V?)
    }

#if defined SSD1306_128_32
    // Init sequence for 128x32 OLED module
    ssd1306_command(SSD1306_DISPLAYOFF);                    // 0xAE
    ssd1306_command(SSD1306_SETDISPLAYCLOCKDIV);            // 0xD5
    ssd1306_command(0x80);                                  // the suggested ratio 0x80
    ssd1306_command(SSD1306_SETMULTIPLEX);                  // 0xA8
    ssd1306_command(0x1F);
    ssd1306_command(SSD1306_SETDISPLAYOFFSET);              // 0xD3
    ssd1306_command(0x0);                                   // no offset
    ssd1306_command(SSD1306_SETSTARTLINE | 0x0);            // line #0
    ssd1306_command(SSD1306_CHARGEPUMP);                    // 0x8D
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x10);
    }
    else
    {
        ssd1306_command(0x14);
    }
    ssd1306_command(SSD1306_MEMORYMODE);                    // 0x20
    ssd1306_command(0x00);                                  // 0x0 act like ks0108
    ssd1306_command(SSD1306_SEGREMAP | 0x1);
    ssd1306_command(SSD1306_COMSCANDEC);
    ssd1306_command(SSD1306_SETCOMPINS);                    // 0xDA
    ssd1306_command(0x02);
    ssd1306_command(SSD1306_SETCONTRAST);                   // 0x81
    ssd1306_command(0x8F);
    ssd1306_command(SSD1306_SETPRECHARGE);                  // 0xd9
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x22);
    }
    else
    {
        ssd1306_command(0xF1);
    }
    ssd1306_command(SSD1306_SETVCOMDETECT);                 // 0xDB
    ssd1306_command(0x40);
    ssd1306_command(SSD1306_DISPLAYALLON_RESUME);           // 0xA4
    ssd1306_command(SSD1306_NORMALDISPLAY);                 // 0xA6
#endif

#if defined SSD1306_128_64
    // Init sequence for 128x64 OLED module
    ssd1306_command(SSD1306_DISPLAYOFF);                    // 0xAE
    ssd1306_command(SSD1306_SETDISPLAYCLOCKDIV);            // 0xD5
    ssd1306_command(0x80);                                  // the suggested ratio 0x80
    ssd1306_command(SSD1306_SETMULTIPLEX);                  // 0xA8
    ssd1306_command(0x3F);
    ssd1306_command(SSD1306_SETDISPLAYOFFSET);              // 0xD3
    ssd1306_command(0x0);                                   // no offset
    ssd1306_command(SSD1306_SETSTARTLINE | 0x0);            // line #0
    ssd1306_command(SSD1306_CHARGEPUMP);                    // 0x8D
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x10);
    }
    else
    {
        ssd1306_command(0x14);
    }
    ssd1306_command(SSD1306_MEMORYMODE);                    // 0x20
    ssd1306_command(0x00);                                  // 0x0 act like ks0108
    ssd1306_command(SSD1306_SEGREMAP | 0x1);
    ssd1306_command(SSD1306_COMSCANDEC);
    ssd1306_command(SSD1306_SETCOMPINS);                    // 0xDA
    ssd1306_command(0x12);
    ssd1306_command(SSD1306_SETCONTRAST);                   // 0x81
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x9F);
    }
    else
    {
        ssd1306_command(0xCF);
    }
    ssd1306_command(SSD1306_SETPRECHARGE);                  // 0xd9
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x22);
    }
    else
    {
        ssd1306_command(0xF1);
    }
    ssd1306_command(SSD1306_SETVCOMDETECT);                 // 0xDB
    ssd1306_command(0x40);
    ssd1306_command(SSD1306_DISPLAYALLON_RESUME);           // 0xA4
    ssd1306_command(SSD1306_NORMALDISPLAY);                 // 0xA6
#endif

#if defined SSD1306_96_16
    // Init sequence for 96x16 OLED module
    ssd1306_command(SSD1306_DISPLAYOFF);                    // 0xAE
    ssd1306_command(SSD1306_SETDISPLAYCLOCKDIV);            // 0xD5
    ssd1306_command(0x80);                                  // the suggested ratio 0x80
    ssd1306_command(SSD1306_SETMULTIPLEX);                  // 0xA8
    ssd1306_command(0x0F);
    ssd1306_command(SSD1306_SETDISPLAYOFFSET);              // 0xD3
    ssd1306_command(0x00);                                   // no offset
    ssd1306_command(SSD1306_SETSTARTLINE | 0x0);            // line #0
    ssd1306_command(SSD1306_CHARGEPUMP);                    // 0x8D
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x10);
    }
    else
    {
        ssd1306_command(0x14);
    }
    ssd1306_command(SSD1306_MEMORYMODE);                    // 0x20
    ssd1306_command(0x00);                                  // 0x0 act like ks0108
    ssd1306_command(SSD1306_SEGREMAP | 0x1);
    ssd1306_command(SSD1306_COMSCANDEC);
    ssd1306_command(SSD1306_SETCOMPINS);                    // 0xDA
    ssd1306_command(0x2);	//ada x12
    ssd1306_command(SSD1306_SETCONTRAST);                   // 0x81
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x10);
    }
    else
    {
        ssd1306_command(0xAF);
    }
    ssd1306_command(SSD1306_SETPRECHARGE);                  // 0xd9
    if (vccstate == SSD1306_EXTERNALVCC)
    {
        ssd1306_command(0x22);
    }
    else
    {
        ssd1306_command(0xF1);
    }
    ssd1306_command(SSD1306_SETVCOMDETECT);                 // 0xDB
    ssd1306_command(0x40);
    ssd1306_command(SSD1306_DISPLAYALLON_RESUME);           // 0xA4
    ssd1306_command(SSD1306_NORMALDISPLAY);                 // 0xA6
#endif

    ssd1306_command(SSD1306_DISPLAYON);//--turn on oled panel
}
示例#6
0
void AmbulanceC::TapOff(){
if(tapTimeout!=NULL) tapTimeout->deleteTimer(); 
			if(dbg) Serial.println("Tap OFF");

		digitalWrite(o_Sink, LOW);}
示例#7
0
void AmbulanceC::StatusLEDOFF(void){digitalWrite(o_StatusLED,LOW);}
/**
 * @brief Beeper::stop_beep
 */
void Beeper::stop_beep()
{
    pinMode(this->pin, OUTPUT);
    digitalWrite(this->pin, LOW);
    this->is_beeping = false;
}
示例#9
0
void AmbulanceC::initializePins(){


//initialize outputs
pinMode(o_SrnOff, OUTPUT); digitalWrite(o_SrnOff, LOW);
pinMode(o_SrnOn, OUTPUT); digitalWrite(o_SrnOn, LOW);
pinMode(o_LHScene, OUTPUT); digitalWrite(o_LHScene, LOW);
pinMode(o_RHScene, OUTPUT); digitalWrite(o_RHScene, LOW);

pinMode(o_AlPow, OUTPUT); digitalWrite(o_AlPow, LOW);
pinMode(o_Sink, OUTPUT); digitalWrite(o_Sink, LOW);
pinMode(23, OUTPUT); digitalWrite(23, LOW);
pinMode(25, OUTPUT); digitalWrite(25, LOW);


pinMode(o_LED1, OUTPUT); digitalWrite(o_LED1, LOW);
pinMode(o_LED3, OUTPUT); digitalWrite(o_LED3, LOW);
pinMode(o_StatusLED, OUTPUT); digitalWrite(o_StatusLED, LOW);
pinMode(o_AlLED, OUTPUT); digitalWrite(o_AlLED, LOW);
pinMode(o_LED5, OUTPUT); digitalWrite(o_LED5, LOW);

//Listening, pull-ups
pinMode(i_pirTamp, INPUT); digitalWrite(i_pirTamp, HIGH); 
pinMode(i_pirAl, INPUT);   digitalWrite(i_pirAl, HIGH); 

pinMode(i_TotAlSw, INPUT); digitalWrite(i_TotAlSw, HIGH); 
pinMode(i_PerAlSw, INPUT); digitalWrite(i_PerAlSw, HIGH);
pinMode(i_DoorSw, INPUT);  digitalWrite(i_DoorSw, HIGH); 

pinMode(i_IsoSw, INPUT);   digitalWrite(i_IsoSw, HIGH);  
pinMode(i_EmSw, INPUT);    digitalWrite(i_EmSw, HIGH); 
pinMode(i_HbrkSw, INPUT);  digitalWrite(i_HbrkSw, HIGH); 
pinMode(i_TapSw, INPUT);   digitalWrite(i_TapSw, HIGH);

}
status_t LSM6DS3Core::beginCore(void)
{
	status_t returnError = IMU_SUCCESS;

	switch (commInterface) {

	case I2C_MODE:
		Wire.begin();
		break;

	case SPI_MODE:
		// start the SPI library:
		SPI.begin();
		// Maximum SPI frequency is 10MHz, could divide by 2 here:
		SPI.setClockDivider(SPI_CLOCK_DIV4);
		// Data is read and written MSb first.
#ifdef ESP32
		SPI.setBitOrder(SPI_MSBFIRST);
#elif ESP8266
		SPI.setBitOrder(SPI_MSBFIRST);
#else
		SPI.setBitOrder(MSBFIRST);
#endif
		// Data is captured on rising edge of clock (CPHA = 0)
		// Base value of the clock is HIGH (CPOL = 1)

		// MODE3 for 328p operation
#ifdef __AVR__
		SPI.setDataMode(SPI_MODE3);
#else
#endif

		// MODE0 for Teensy 3.1 operation
#ifdef __MK20DX256__
		SPI.setDataMode(SPI_MODE0);
#else
#endif
		
		// initalize the  data ready and chip select pins:
		pinMode(chipSelectPin, OUTPUT);
		digitalWrite(chipSelectPin, HIGH);
		break;
	default:
		break;
	}

	//Spin for a few ms
	volatile uint8_t temp = 0;
	for( uint16_t i = 0; i < 10000; i++ )
	{
		temp++;
	}

	//Check the ID register to determine if the operation was a success.
	uint8_t readCheck;
	readRegister(&readCheck, LSM6DS3_ACC_GYRO_WHO_AM_I_REG);
	if( readCheck != 0x69 )
	{
		returnError = IMU_HW_ERROR;
	}

	return returnError;

}
/**
 * @brief Beeper::start_beep
 */
void Beeper::start_beep()
{
    pinMode(this->pin, OUTPUT);
    digitalWrite(this->pin, HIGH);
    this->is_beeping = true;
}
//****************************************************************************//
//
//  ReadRegisterRegion
//
//  Parameters:
//    *outputPointer -- Pass &variable (base address of) to save read data to
//    offset -- register to read
//    length -- number of bytes to read
//
//  Note:  Does not know if the target memory space is an array or not, or
//    if there is the array is big enough.  if the variable passed is only
//    two bytes long and 3 bytes are requested, this will over-write some
//    other memory!
//
//****************************************************************************//
status_t LSM6DS3Core::readRegisterRegion(uint8_t *outputPointer , uint8_t offset, uint8_t length)
{
	status_t returnError = IMU_SUCCESS;

	//define pointer that will point to the external space
	uint8_t i = 0;
	uint8_t c = 0;
	uint8_t tempFFCounter = 0;

	switch (commInterface) {

	case I2C_MODE:
		Wire.beginTransmission(I2CAddress);
		Wire.write(offset);
		if( Wire.endTransmission() != 0 )
		{
			returnError = IMU_HW_ERROR;
		}
		else  //OK, all worked, keep going
		{
			// request 6 bytes from slave device
			Wire.requestFrom(I2CAddress, length);
			while ( (Wire.available()) && (i < length))  // slave may send less than requested
			{
				c = Wire.read(); // receive a byte as character
				*outputPointer = c;
				outputPointer++;
				i++;
			}
		}
		break;

	case SPI_MODE:
		// take the chip select low to select the device:
		digitalWrite(chipSelectPin, LOW);
		// send the device the register you want to read:
		SPI.transfer(offset | 0x80);  //Ored with "read request" bit
		while ( i < length ) // slave may send less than requested
		{
			c = SPI.transfer(0x00); // receive a byte as character
			if( c == 0xFF )
			{
				//May have problem
				tempFFCounter++;
			}
			*outputPointer = c;
			outputPointer++;
			i++;
		}
		if( tempFFCounter == i )
		{
			//Ok, we've recieved all ones, report
			returnError = IMU_ALL_ONES_WARNING;
		}
		// take the chip select high to de-select:
		digitalWrite(chipSelectPin, HIGH);
		break;

	default:
		break;
	}

	return returnError;
}
示例#13
0
void Mrf24j::reset(void) {
    digitalWrite(_pin_reset, LOW);
    delay(10);  // just my gut
    digitalWrite(_pin_reset, HIGH);
    delay(20);  // from manual
}
示例#14
0
uint8_t PSX64::config_gamepad(uint8_t clk, uint8_t cmd, uint8_t att, uint8_t dat, bool pressures, bool rumble) {

   uint8_t temp[sizeof(type_read)];
  
 _clk_mask = maskToBitNum(digitalPinToBitMask(clk));
 _clk_oreg = portOutputRegister(digitalPinToPort(clk));
 _cmd_mask = maskToBitNum(digitalPinToBitMask(cmd));
 _cmd_oreg = portOutputRegister(digitalPinToPort(cmd));
 _att_mask = maskToBitNum(digitalPinToBitMask(att));
 _att_oreg = portOutputRegister(digitalPinToPort(att));
 _dat_mask = maskToBitNum(digitalPinToBitMask(dat));
 _dat_ireg = portInputRegister(digitalPinToPort(dat));
  

  pinMode(clk, OUTPUT); //configure ports
  pinMode(att, OUTPUT);
  pinMode(cmd, OUTPUT);
  pinMode(dat, INPUT);

  digitalWrite(dat, HIGH); //enable pull-up 
    
   SET(*_cmd_oreg,_cmd_mask); // SET(*_cmd_oreg,_cmd_mask);
   SET(*_clk_oreg,_clk_mask);
   
   //new error checking. First, read gamepad a few times to see if it's talking
   read_gamepad();
   read_gamepad();
   
   //see if it talked
   if(PS2data[1] != 0x41 && PS2data[1] != 0x73 && PS2data[1] != 0x79){ //see if mode came back. If still anything but 41, 73 or 79, then it's not talking
      #ifdef PSX64_DEBUG
		Serial.println("Controller mode not matched or no controller found");
		Serial.print("Expected 0x41 or 0x73, got ");
		Serial.println(PS2data[1], HEX);
	  #endif
	 
	 return 1; //return error code 1
	}
  
  //try setting mode, increasing delays if need be. 
  read_delay = 1;
  
  for(int y = 0; y <= 10; y++)
  {
   sendCommandString(enter_config, sizeof(enter_config)); //start config run
   
   //read type
   	delayMicroseconds(CTRL_BYTE_DELAY);

	SET(*_cmd_oreg,_cmd_mask);
    SET(*_clk_oreg,_clk_mask);
    CLR(*_att_oreg,_att_mask); // low enable joystick
	
    delayMicroseconds(CTRL_BYTE_DELAY);

    for (int i = 0; i<9; i++) {
	  temp[i] = _gamepad_shiftinout(type_read[i]);
    }

	SET(*_att_oreg,_att_mask); // HI disable joystick
	
	controller_type = temp[3];
   
   sendCommandString(set_mode, sizeof(set_mode));
   if(rumble){ sendCommandString(enable_rumble, sizeof(enable_rumble)); en_Rumble = true; }
   if(pressures){ sendCommandString(set_bytes_large, sizeof(set_bytes_large)); en_Pressures = true; }
   sendCommandString(exit_config, sizeof(exit_config));
   
   read_gamepad();
   
   if(pressures){
	if(PS2data[1] == 0x79)
		break;
	if(PS2data[1] == 0x73)
		return 3;
   }
   
    if(PS2data[1] == 0x73)
      break;
      
    if(y == 10){
		#ifdef PSX64_DEBUG
		Serial.println("Controller not accepting commands");
		Serial.print("mode stil set at");
		Serial.println(PS2data[1], HEX);
		#endif
      return 2; //exit function with error
	  }
    
    read_delay += 1; //add 1ms to read_delay
  }
   
 return 0; //no error if here
}
示例#15
0
void AmbulanceC::RHSceneOn(void){
	if(prnt) Serial.println("RHSceneOn()");
	digitalWrite(o_LHScene, LOW);
	digitalWrite(o_RHScene, HIGH);
}
示例#16
0
void AmbulanceC::disableblinkAlLED(void){
	timerblinkAlLEDFast->disable();
	timerblinkAlLEDMedium->disable();
	timerblinkAlLEDSlow->disable();
	digitalWrite(o_AlLED,LOW);
}
示例#17
0
//Tap///////////////////////////////////////////////////////////////////////////////////
void AmbulanceC::TapOn(void){digitalWrite(o_Sink, HIGH);
		if(dbg) Serial.println("Tap ON");

tapTimeout=t.setTimeout(60000, TAPOFF);
}
示例#18
0
void AmbulanceC::AlLEDL(){digitalWrite(o_AlLED,LOW);}
示例#19
0
void AmbulanceC::StatusLEDON(void) { digitalWrite(o_StatusLED,HIGH);}
示例#20
0
void AmbulanceC::AlLEDH(){digitalWrite(o_AlLED,HIGH);}
void LiquidCrystal::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) {
  if (lines > 1) {
    _displayfunction |= LCD_2LINE;
  }
  _numlines = lines;
  _currline = 0;

  // for some 1 line displays you can select a 10 pixel high font
  if ((dotsize != 0) && (lines == 1)) {
    _displayfunction |= LCD_5x10DOTS;
  }

  // SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
  // according to datasheet, we need at least 40ms after power rises above 2.7V
  // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
  delayMicroseconds(50000); 
  // Now we pull both RS and R/W low to begin commands
  digitalWrite(_rs_pin, LOW);
  digitalWrite(_enable_pin, LOW);
  if (_rw_pin != 255) { 
    digitalWrite(_rw_pin, LOW);
  }
  
  //put the LCD into 4 bit or 8 bit mode
  if (! (_displayfunction & LCD_8BITMODE)) {
    // this is according to the hitachi HD44780 datasheet
    // figure 24, pg 46

    // we start in 8bit mode, try to set 4 bit mode
    write4bits(0x03);
    delayMicroseconds(4500); // wait min 4.1ms

    // second try
    write4bits(0x03);
    delayMicroseconds(4500); // wait min 4.1ms
    
    // third go!
    write4bits(0x03); 
    delayMicroseconds(150);

    // finally, set to 4-bit interface
    write4bits(0x02); 
  } else {
    // this is according to the hitachi HD44780 datasheet
    // page 45 figure 23

    // Send function set command sequence
    command(LCD_FUNCTIONSET | _displayfunction);
    delayMicroseconds(4500);  // wait more than 4.1ms

    // second try
    command(LCD_FUNCTIONSET | _displayfunction);
    delayMicroseconds(150);

    // third go
    command(LCD_FUNCTIONSET | _displayfunction);
  }

  // finally, set # lines, font size, etc.
  command(LCD_FUNCTIONSET | _displayfunction);  

  // turn the display on with no cursor or blinking default
  _displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;  
  display();

  // clear it off
  clear();

  // Initialize to default text direction (for romance languages)
  _displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;
  // set the entry mode
  command(LCD_ENTRYMODESET | _displaymode);

}
示例#22
0
void AmbulanceC::srnOn(void){
	if(prnt) Serial.println("SrnOn");
digitalWrite(o_SrnOn, HIGH);
t.setTimeout(500, SRNONL);
}
示例#23
0
bool EDID::writeData(uint8_t *eepromdata, uint8_t length, bool fromProgMem)
{
  bool err = true;

  digitalWrite(LED_2, HIGH);
  #if DEBUG > 0
    Serial.println(F("Writing..."));
  #endif
  for(uint16_t addr = 0; addr < EEPROMSIZE; addr++)
  {
    byte b;

    if(addr < length)
    {
      if(fromProgMem)
        b = pgm_read_byte(eepromdata + addr);
      else
        b = eepromdata[addr];
    }
    else
      b = 0xFF;

    writeByte(addr, b);
    delay(5);
  }
  #if DEBUG > 0
    Serial.println(F("Done."));
    Serial.println(F("Verifying..."));
  #endif
  for(uint16_t addr = 0; addr < EEPROMSIZE; addr++)
  {
    byte b, d;
    
    if (addr < length)
    {
      if(fromProgMem)
        b = pgm_read_byte(eepromdata + addr);
      else
        b = eepromdata[addr];
    }
    else
      b = 0xFF;
 
    d = readByte(addr);
    
    if (b != d)
    {
      #if DEBUG > 0
        Serial.print(F("Verification failed at 0x"));
        Serial.println(addr, HEX);
      #endif
      err = false;
      break;
    }
  }
  #if DEBUG > 0
    Serial.println(F("Done."));
  #endif
  digitalWrite(LED_2, LOW);
  return err;
}
示例#24
0
void AmbulanceC::srnOnL(void){
digitalWrite(o_SrnOn, LOW);
}
void flash(int pin, int length) {
  digitalWrite(pin, HIGH);
  delay(length);
  digitalWrite(pin, LOW);
}
示例#26
0
void AmbulanceC::srnOff(void){
	if(prnt) Serial.println("SrnOff");
digitalWrite(o_SrnOff, HIGH);
	delay(500);
	digitalWrite(o_SrnOff, LOW);
}
示例#27
0
void Bounce::write(int new_state)
{
  this->state = new_state;
  digitalWrite(pin,state);
}
示例#28
0
void AmbulanceC::disableblinkScene(void){
	timerblinkScene->disable();
	digitalWrite(o_RHScene, LOW);
	digitalWrite(o_LHScene, LOW);
}
示例#29
0
void *ChangeTHRepresentation (void *param)
{
    (void)param;
    OCStackResult result = OC_STACK_ERROR;
    modCounter += 1;
    if (modCounter % 10 ==
        0) // Matching the timing that the Linux Sample Server App uses for the same functionality.
    {

        byte dht11_dat[5];
        byte i;// start condition

        digitalWrite(dht11_pin, LOW);
        delay(18);
        digitalWrite(dht11_pin, HIGH);
        delayMicroseconds(1);
        pinMode(dht11_pin, INPUT);
        delayMicroseconds(40);

        if (digitalRead(dht11_pin))
        {
            Serial.println("dht11 start condition 1 not met"); // wait for DHT response signal: LOW
            delay(1000);
            return NULL;
        }
        delayMicroseconds(80);
        if (!digitalRead(dht11_pin))
        {
            Serial.println("dht11 start condition 2 not met");  //wair for second response signal:HIGH
            return NULL;
        }

        delayMicroseconds(80);// now ready for data reception
        for (i = 0; i < 5; i++)
        {
            dht11_dat[i] = read_dht11_dat();
        }  //recieved 40 bits data. Details are described in datasheet

        pinMode(dht11_pin, OUTPUT);
        digitalWrite(dht11_pin, HIGH);
        byte dht11_check_sum = dht11_dat[0] + dht11_dat[2]; // check check_sum
        if (dht11_dat[4] != dht11_check_sum)
        {
            Serial.println("DHT11 checksum error");
        }
        Serial.print("Current humdity = ");
        Serial.print(dht11_dat[0], DEC);
        Serial.print("%  ");
        Serial.print("temperature = ");
        Serial.print(dht11_dat[2], DEC);
        Serial.println("C  ");

        TH.m_humid = dht11_dat[0];
        TH.m_temp = dht11_dat[2];

        if (g_THUnderObservation)
        {
            OC_LOG_V(INFO, TAG, " =====> Notifying stack of new humid level %d\n", TH.m_humid);
            OC_LOG_V(INFO, TAG, " =====> Notifying stack of new temp level %d\n", TH.m_temp);

            result = OCNotifyAllObservers (TH.m_handle, OC_NA_QOS);

            if (OC_STACK_NO_OBSERVERS == result)
            {
                g_THUnderObservation = 0;
            }
        }
    }
    return NULL;
}
示例#30
0
void DigitalTube::setSegments(int n){
  for (int i=0; i < 8; i++){
    digitalWrite(segmentPins[i], ! digits[n][i]);
  } 

}