//display function.Write to full-screen.
void TM1637::display(int8_t DispData[])
{
  int8_t SegData[4];
  uint8_t i;
  for(i = 0;i < 4;i ++)
  {
    SegData[i] = DispData[i];
  }
  coding(SegData);
  start();          //start signal sent to TM1637 from MCU
  writeByte(ADDR_AUTO);//
  stop();           //
  start();          //
  writeByte(Cmd_SetAddr);//
  for(i=0;i < 4;i ++)
  {
    writeByte(SegData[i]);        //
  }
  stop();           //
  start();          //
  writeByte(Cmd_DispCtrl);//
  stop();           //
}
void digitalWritePiFaceSpecial (int pin, int value)
{
    uint8_t mask = 1 << pin ;
    uint8_t old ;

    old = readByte (GPIOA) ;

    if (value == 0)
        old &= (~mask) ;
    else
        old |=   mask ;

    writeByte (GPIOA, old) ;
}
Beispiel #3
0
void mcp23016::begin(bool protocolInitOverride) {
	if (!protocolInitOverride && !_error){
		Wire.begin();
		#if ARDUINO >= 157
			Wire.setClock(400000UL); // Set I2C frequency to 400kHz
		#else
			TWBR = ((F_CPU / 400000UL) - 16) / 2; // Set I2C frequency to 400kHz
		#endif
	}	
	delay(100);
	writeByte(IOCON,0b00000000);//read datasheet for details!
	_gpioDirection = 0xFFFF;//all in
	_gpioState = 0x0000;//all low 
}
// Display function.Write to full-screen.
void TM1637::display(int8_t disp_data[])
{
  int8_t seg_data[DIGITS];
  uint8_t i;

  for (i = 0; i < DIGITS; i++)
    seg_data[i] = disp_data[i];

  coding(seg_data);
  start();              // Start signal sent to TM1637 from MCU
  writeByte(ADDR_AUTO); // Command1: Set data
  stop();
  start();
  writeByte(cmd_set_addr); // Command2: Set address (automatic address adding)

  for (i = 0; i < DIGITS; i++)
    writeByte(seg_data[i]); // Transfer display data (8 bits x num_of_digits)

  stop();
  start();
  writeByte(cmd_disp_ctrl); // Control display
  stop();
}
TextLCD::TextLCD(PinName rs, PinName e, PinName d4, PinName d5,
                 PinName d6, PinName d7, LCDType type) : _rs(rs),
        _e(e), _d(d4, d5, d6, d7),
        _type(type) {

    _e  = 1;
    _rs = 0;            // command mode

    wait(0.015);        // Wait 15ms to ensure powered up

    // send "Display Settings" 3 times (Only top nibble of 0x30 as we've got 4-bit bus)
    for (int i=0; i<3; i++) {
        writeByte(0x3);
        wait(0.00164);  // this command takes 1.64ms, so wait for it
    }
    writeByte(0x2);     // 4-bit mode
    wait(0.000040f);    // most instructions take 40us

    writeCommand(0x28); // Function set 001 BW N F - -
    writeCommand(0x0C);
    writeCommand(0x6);  // Cursor Direction and Display Shift : 0000 01 CD S (CD 0-left, 1-right S(hift) 0-no, 1-yes
    cls();
}
Beispiel #6
0
CSymbol* CData::addVariable (const int &scope, const std::string &name, const int &type, int size, const int &address)
{
   if (size == 0) {
      size = getTypeSize(type);
   }

   CSymbol *symbol = new CSymbol (scope, name, type, size, CSymbol::VAR, address);

   _symbols.push_back(symbol);

   if (type == CSymbol::STRING) {
      // Para strings constantes e variaveis eh necessario indicar a categoria
      writeByte(CSymbol::VAR);
   }

   //_data += symbol->getBinary();
   for (int i=0; i < symbol->getTypeSize(); i++) {
      // TODO: horrivel :-)
      writeByte ('\0');
   }

   return symbol;
}
Beispiel #7
0
/*
 * packetPing(): send Ping heart beat data to OneNet
 * 
 */
edp_pkt *packetPing()
{
  int32 remainlen = 0x00;
  edp_pkt* pkt;

  if((pkt = packetCreate()) == NULL)
    return NULL;
  /* msg type */
  writeByte(pkt, PINGREQ);
  /* remain len */
  writeRemainlen(pkt, remainlen); 

  return pkt;
}
Beispiel #8
0
void DDS::setFreq(double frequency){

  //enter frequency as Hz
  if(frequency > 40000000){
      Serial.println("Frequency is set Higher than board can output");
      Serial.println("Setting to Maximum Freq ");
      frequency = 40000000;
  }
  
  #ifdef DEBUG
    Serial.print("Freq: ");
    Serial.print(frequency);
    Serial.println(" Hz");    
  #endif
  
  int32_t freq = frequency * 4294967295 / 125000000;  // note 125 MHz clock on 9850
  for (int b = 0; b < 4; b++, freq>>=8) {
    writeByte(freq & 0xFF);
  }
  writeByte(0x000);   // Final control byte
  pulseHigh(FU_UD);  // Done!  Should see output
  
}
Beispiel #9
0
void CDMRTX::process()
{
  if (m_state == DMRTXSTATE_IDLE)
    return;

  if (m_poLen == 0U) {
    switch (m_state) {
      case DMRTXSTATE_SLOT1:
        createData(0U);
        m_state = DMRTXSTATE_CACH2;
        break;

      case DMRTXSTATE_CACH2:
        createCACH(1U, 0U);
        m_state = DMRTXSTATE_SLOT2;
        break;

      case DMRTXSTATE_SLOT2:
        createData(1U);
        m_state = DMRTXSTATE_CACH1;
        break;
        
      default:
        createCACH(0U, 1U);
        m_state = DMRTXSTATE_SLOT1;
        break;
    }
  }

  if (m_poLen > 0U) {
    uint16_t space = io.getSpace();
    
    while (space > (4U * DMR_RADIO_SYMBOL_LENGTH) && space < 1000U) {
      uint8_t c = m_poBuffer[m_poPtr];
      uint8_t m = m_markBuffer[m_poPtr];
      m_poPtr++;

      writeByte(c, m);

      space -= 4U * DMR_RADIO_SYMBOL_LENGTH;
      
      if (m_poPtr >= m_poLen) {
        m_poPtr = 0U;
        m_poLen = 0U;
        return;
      }
    }
  }
}
Beispiel #10
0
// Read the thermocouple temperature either in Degree Celsius or Fahrenheit. Internally,
// the conversion takes place in the background within 155 ms, or longer depending on the
// number of samples in each reading (see CR1).
// Returns the temperature, or an error (FAULT_OPEN, FAULT_VOLTAGE or NO_MAX31856)
double	MAX31856::readThermocouple(byte unit)
{
    double temperature;
    long data;

    // Select the MAX31856 chip
    digitalWrite(_cs, LOW);

    // Read data starting with register 0x0c
    writeByte(READ_OPERATION(0x0c));

    // Read 4 registers
    data = readData();

    // Deselect MAX31856 chip
    digitalWrite(_cs, HIGH);

    // If there is no communication from the IC then data will be all 1's because
    // of the internal pullup on the data line (INPUT_PULLUP)
    if (data == 0xFFFFFFFF)
        return NO_MAX31856;

    // If the value is zero then the temperature could be exactly 0.000 (rare), or
    // the IC's registers are uninitialized.
    if (data == 0 && verifyMAX31856() == NO_MAX31856)
        return NO_MAX31856;

    // Was there an error?
    if (data & SR_FAULT_OPEN)
        temperature = FAULT_OPEN;
    else if (data & SR_FAULT_UNDER_OVER_VOLTAGE)
        temperature = FAULT_VOLTAGE;
    else {
        // Strip the unused bits and the Fault Status Register
        data = data >> 13;

        // Negative temperatures have been automagically handled by the shift above :-)

        // Convert to Celsius
        temperature = (double) data * 0.0078125;
	
        // Convert to Fahrenheit if desired
        if (unit == FAHRENHEIT)
            temperature = (temperature * 9.0/5.0)+ 32;
    }

    // Return the temperature
    return (temperature);
}
Beispiel #11
0
void Sensor::playMelody(unsigned char* song, int length){

	
	
	for(int i = 0; i<length; i+=2)
	{

		if(song[i+1] != 100)
		{
			writeByte(ID, BUZZER_DATA_TIME, 254);
			writeByte(ID, BUZZER_DATA_NOTE, song[i+1]);
			usleep(40000*song[i]);
		}
		else
		{
			writeByte(ID, BUZZER_DATA_TIME, 0);
			usleep(40000*song[i]);
		}
			
		
	}
	writeByte(ID, BUZZER_DATA_TIME, 0);
	
}
Beispiel #12
0
static int _wiringPiSetupPiFace (void)
{
  if ((spiFd = open (spiDevice, O_RDWR)) < 0)
    return -1 ;

// Set SPI parameters
//	Why are we doing a read after write?
//	I don't know - just blindliy copying an example elsewhere... -GH-

  if (ioctl (spiFd, SPI_IOC_WR_MODE, &spiMode) < 0)
    return -1 ;

  if (ioctl (spiFd, SPI_IOC_RD_MODE, &spiMode) < 0)
    return -1 ;

  if (ioctl (spiFd, SPI_IOC_WR_BITS_PER_WORD, &spiBPW) < 0)
    return -1 ;

  if (ioctl (spiFd, SPI_IOC_RD_BITS_PER_WORD, &spiBPW) < 0)
    return -1 ;

  if (ioctl (spiFd, SPI_IOC_WR_MAX_SPEED_HZ, &spiSpeed) < 0)
    return -1 ;

  if (ioctl (spiFd, SPI_IOC_RD_MAX_SPEED_HZ, &spiSpeed) < 0)
    return -1 ;

// Setup the MCP23S17

  writeByte (IOCON, IOCON_INIT) ;

  writeByte (IODIRA, 0x00) ;	// Port A -> Outputs
  writeByte (IODIRB, 0xFF) ;	// Port B -> Inputs

  return 0 ;
}
Beispiel #13
0
void myDigitalWrite (struct wiringPiNodeStruct *node, int pin, int value)
{
  uint8_t mask, old ;

  pin -= node->pinBase ;
  mask = 1 << pin ;
  old  = readByte (MCP23x17_GPIOA) ;

  if (value == 0)
    old &= (~mask) ;
  else
    old |=   mask ;

  writeByte (MCP23x17_GPIOA, old) ;
}
Beispiel #14
0
int mcp23s17Setup (const int pinBase, const int spiPort, const int devId)
{
  int    x ;
  struct wiringPiNodeStruct *node ;

  if ((x = wiringPiSPISetup (spiPort, MCP_SPEED)) < 0)
    return x ;

  writeByte (spiPort, devId, MCP23x17_IOCON,  IOCON_INIT | IOCON_HAEN) ;
  writeByte (spiPort, devId, MCP23x17_IOCONB, IOCON_INIT | IOCON_HAEN) ;

  node = wiringPiNewNode (pinBase, 16) ;

  node->data0           = spiPort ;
  node->data1           = devId ;
  node->pinMode         = myPinMode ;
  node->pullUpDnControl = myPullUpDnControl ;
  node->digitalRead     = myDigitalRead ;
  node->digitalWrite    = myDigitalWrite ;
  node->data2           = readByte (spiPort, devId, MCP23x17_OLATA) ;
  node->data3           = readByte (spiPort, devId, MCP23x17_OLATB) ;

  return 0 ;
}
void SX1509::keypad(byte rows, byte columns, unsigned int sleepTime, byte scanTime, byte debounceTime)
{
	unsigned int tempWord;
	byte tempByte;
	
	// If clock hasn't been set up, set it to internal 2MHz
	if (_clkX == 0)
		clock(INTERNAL_CLOCK_2MHZ);
	
	// Set regDir 0:7 outputs, 8:15 inputs:
	tempWord = readWord(REG_DIR_B);
	for (int i=0; i<rows; i++)
		tempWord &= ~(1<<i);
	for (int i=8; i<(columns * 2); i++)
		tempWord |= (1<<i);
	writeWord(REG_DIR_B, tempWord);
	
	// Set regOpenDrain on 0:7:
	tempByte = readByte(REG_OPEN_DRAIN_A);
	for (int i=0; i<rows; i++)
		tempByte |= (1<<i);
	writeByte(REG_OPEN_DRAIN_A, tempByte);
	
	// Set regPullUp on 8:15:
	tempByte = readByte(REG_PULL_UP_B);
	for (int i=0; i<columns; i++)
		tempByte |= (1<<i);
	writeByte(REG_PULL_UP_B, tempByte);
	
	// Debounce Time must be less than scan time
	debounceTime = constrain(debounceTime, 1, 64);
	scanTime = constrain(scanTime, 1, 128);
	if (debounceTime >= scanTime)
	{
		debounceTime = scanTime >> 1; // Force debounceTime to be less than scanTime
	}
Beispiel #16
0
void pullUpDnControlPiFaceSpecial (int pin, int pud)
{
  uint8_t mask = 1 << pin ;
  uint8_t old ;

  old = readByte (GPPUB) ;

  if (pud == PUD_UP)
    old |=   mask ;
  else
    old &= (~mask) ;

  writeByte (GPPUB, old) ;

}
Beispiel #17
0
void MAX7219PrintTimer(unsigned long n)
{
	if ((n>100)||(n==0))
	{
		writeByte(digit0,DASH);
		writeByte(digit1,DASH);
		writeByte(digit2,DASH);
		writeByte(digit5,DASH);
		return;

	}
	writeByte(digit0, DASH);
	writeByte(digit1,n % 10);
	writeByte(digit2,n / 10);
	writeByte(digit5, DASH);

}
Beispiel #18
0
 void LCD4884::writeChar(unsigned char c, char mode)
 {
   unsigned char line;
   unsigned char *pFont;
   byte ch;
   
   pFont = (unsigned char*) font6_8;
   c -= 32;
   
   for(line = 0; line < 6; line++)
   {
     ch = pgm_read_byte(pFont + c * 6 + line);
     writeByte( (mode==MENU_NORMAL) ? ch : (ch ^ 0xff), 1);
   }
 }
void
Enc28J60Network::memblock_mv_cb(uint16_t dest, uint16_t src, uint16_t len)
{
  //as ENC28J60 DMA is unable to copy single bytes:
  if (len == 1)
    {
      writeByte(dest,readByte(src));
    }
  else
    {
      // calculate address of last byte
      len += src - 1;

      /*  1. Appropriately program the EDMAST, EDMAND
       and EDMADST register pairs. The EDMAST
       registers should point to the first byte to copy
       from, the EDMAND registers should point to the
       last byte to copy and the EDMADST registers
       should point to the first byte in the destination
       range. The destination range will always be
       linear, never wrapping at any values except from
       8191 to 0 (the 8-Kbyte memory boundary).
       Extreme care should be taken when
       programming the start and end pointers to
       prevent a never ending DMA operation which
       would overwrite the entire 8-Kbyte buffer.
       */
      writeRegPair(EDMASTL, src);
      writeRegPair(EDMADSTL, dest);

      if ((src <= RXSTOP_INIT)&& (len > RXSTOP_INIT))len -= (RXSTOP_INIT-RXSTART_INIT);
      writeRegPair(EDMANDL, len);

      /*
       2. If an interrupt at the end of the copy process is
       desired, set EIE.DMAIE and EIE.INTIE and
       clear EIR.DMAIF.

       3. Verify that ECON1.CSUMEN is clear. */
      writeOp(ENC28J60_BIT_FIELD_CLR, ECON1, ECON1_CSUMEN);

      /* 4. Start the DMA copy by setting ECON1.DMAST. */
      writeOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_DMAST);

      // wait until runnig DMA is completed
      while (readOp(ENC28J60_READ_CTRL_REG, ECON1) & ECON1_DMAST);
    }
}
Beispiel #20
0
uint8_t initMPU(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t source)
{
	uint8_t b = 0;

	readByte(devAddr, regAddr, &b);
	msDelay(2);
	uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
	source <<= (bitStart - length + 1);	// shift data into correct position
	source &= mask;	// zero all non-important bits in data

	b &= ~(mask); // zero all important bits in existing byte
	b |= source; // combine data with existing byte

	writeByte(devAddr, regAddr, b);
	return b;
}
Beispiel #21
0
void OutBuffer::writenl()
{
#if _WIN32
#if M_UNICODE
    write4(0x000A000D);         // newline is CR,LF on Microsoft OS's
#else
    writeword(0x0A0D);          // newline is CR,LF on Microsoft OS's
#endif
#else
#if M_UNICODE
    writeword('\n');
#else
    writeByte('\n');
#endif
#endif
}
boolean SFE_TSL2561::setInterruptControl(unsigned char control, unsigned char persist)
// Sets up interrupt operations
// If control = 0, interrupt output disabled
// If control = 1, use level interrupt, see setInterruptThreshold()
// If persist = 0, every integration cycle generates an interrupt
// If persist = 1, any value outside of threshold generates an interrupt
// If persist = 2 to 15, value must be outside of threshold for 2 to 15 integration cycles
// Returns true (1) if successful, false (0) if there was an I2C error
// (Also see getError() below)
{
    // Place control and persist bits into proper location in interrupt control register
    if (writeByte(TSL2561_REG_INTCTL,((control | 0B00000011) << 4) & (persist | 0B00001111)))
        return(true);

    return(false);
}
/** send instruction packet */
void AX12::sendPacket (byte _id, byte datalength, byte instruction, byte* data) {

    byte checksum = 0;
    writeByte (0xFF);
    writeByte (0xFF);
    checksum += writeByte (_id);
    checksum += writeByte (datalength + 2);
    checksum += writeByte (instruction);
    for (byte f=0; f<datalength; f++) {     // data = parámetros
      checksum += writeByte (data[f]);
    }
    // checksum =
    writeByte (~checksum);
    serialHandle->listen();
}
bool EEPROMClassEx::updateBit(int address, uint8_t bit, bool value) 
{
	  if (bit> 7) return false; 
	  
	  byte byteValInput  = readByte(address);
	  byte byteValOutput = byteValInput;	  
	  // Set bit
	  if (value) {	    
		byteValOutput |= (1 << bit);  //Set bit to 1
	  } else {		
	    byteValOutput &= !(1 << bit); //Set bit to 0
	  }
	  // Store if different from input
	  if (byteValOutput!=byteValInput) {
		writeByte(address, byteValOutput);	  
	  }
}
Beispiel #25
0
/***
* Function: setHeaterState(byte state)
* Description: Set heater state
* Params: state - Heater state setting
* Returns: 0 if state was successfully written, 1 if not
***/
byte Si7020::setHeaterState(byte state)
{
	byte result = 0;
	byte regValue = 0;
	
	result = readByte(SI7020_CMD_WRITE_RHT_USER_REG, &regValue);
	
	if (result == 0)
	{
		regValue &= (~SI7020_HEATER_MASK); // Clear resolution bits
		regValue |= (state & SI7020_HEATER_MASK); // Set new resolution bits
		
		result = writeByte(SI7020_CMD_WRITE_RHT_USER_REG, regValue); // Write new value to register
	}
	
	return result;
}
Beispiel #26
0
/** Read 64 bit unique ROM code.
 *
 * @return 0 if no timeout has occured.
 */
int DS18B20::readROM()
{
  int result = reset();

  if (0 == result)
  {
    writeByte(0x33); // Read ROM

    // read 64 bit unique code
    for (unsigned int i = 0; i < 8; i++)
    {
      _romCode[i] = readByte();
    }
  }

  return result;
}
bool I2CSingleByteMasterPollingFeature::setBits(uint8_t address,uint8_t mask) const {

    uint8_t value;

    // read current register value

    if(!readByte(address,value))
        return false;

    // set the bits

    value|=mask;

    // write back to the register

    return writeByte(address,value);
}
Beispiel #28
0
uint32_t TBinaryProtocol::writeMessageBegin(const std::string& name,
                                            const TMessageType messageType,
                                            const int32_t seqid) {
  if (strict_write_) {
    int32_t version = (VERSION_1) | ((int32_t)messageType);
    uint32_t wsize = 0;
    wsize += writeI32(version);
    wsize += writeString(name);
    wsize += writeI32(seqid);
    return wsize;
  } else {
    uint32_t wsize = 0;
    wsize += writeString(name);
    wsize += writeByte((int8_t)messageType);
    wsize += writeI32(seqid);
    return wsize;
  }
}
Beispiel #29
0
	void Buffer::write16(uint16_t value)
	{
		if (position % 8)
		{
			if (position + 16 > size * 8)
			{
				data = (char*)realloc(data, bytes(position + 16));
				size = bytes(position + 16);
			}
			writeByte(value >> 8);
			position += 8;
			writeByte(value & 0xFF);
			position += 8;
		}
		else
		{
			// We are on an even position
			if (position / 8 + 2 > size)
Beispiel #30
0
void gotoBank(int16_t bank){
	//static int16_t currentBank = -1;
	
	if (bank != currentBank){
		
		if (useSPI == 1){
			writeByte (0, _SNESBankAndData, GPIOA, bank);//SNESBankAndData._writeRegister(GPIOA,bank)
		}
		//use GPIO
		else{
				
				writeFlipflops(bank, GPIO_TRIG_BANK);
			
		}
		currentBank = bank;
		BankWrites++;
	}
	
}