void LCD_Low_Level::sendData(uint8_t value, uint8_t rs_bit) { writeControl(rs_bit, 0); if (_display_function & LCD_8BitMode) { write8bits(value); } else { write4bits((value & 0xF0)>>4); write4bits(value & 0x0F); } }
//Initializes the LCD as described in the HD44780 datasheet. //Normally called only by the initialize() function in utility.c. void lcdInit() { //configure LCD E (Enable) control pin as an output sbi(DDRD, 6); //configure LCD RS (Register Select) control pin as an output sbi(DDRD, 7); //set LCD E (Enable) line low inititally, so it can rise later cbi(PORTD, 6); //wait 15ms after power on delayMs(15); //Issue 'Function Set' commands to initialize LCD for 8-bit interface mode writeControl(0x38); delayUs(4900); //+100us in writeControl = 5000us or 5ms total writeControl(0x38); delayUs(50); //+100us in writeControl = 150us total writeControl(0x38); //Function Set command to specify 2 display lines and character font writeControl(0x38); //Display off lcdOff(); //Clear display clearScreen(); //Set entry mode writeControl(0x06); //Display on lcdOn(); }
void Intel8255::writeByPort(uint8_t p03,uint8_t data) { switch (p03) { case 0: writePortA(data); break; case 1: writePortB(data); break; case 2: writePortC(data); break; case 3: writeControl(data); break; } }
// // send a heartbeat and record time // The "last heartbeat" time is recorded in a global variable // such that the service thread can decice whether a new // heartbeat is due. // static void heartbeat() { unsigned char seq[2]; seq[0] = 0x7e; seq[1] = 0xfe; writeControl(seq, 2); lastbeat = time(NULL); }
void Intel8255::reset(void) { IBF_A = IBF_B = 0; OBF_A = OBF_B = 0; INTE_A = INTE_B = 0; INTE_1 = INTE_2 = 0; INTR_A = INTR_B = 0; writeControl(0x9B); /* default: port A input, port B input, port C input mode 0 mode 0 */ latchOutPortA = 0; latchOutPortB = 0; latchOutPortC = 0; }
// // Number of stop bits must be 1 or 2. // Number of data bits can be 5,6,7,8 // Hardware handshake (rtscts) can be on of off. // microHam devices ALWAY use "no parity". // int uh_open_radio(int baud, int databits, int stopbits, int rtscts) { unsigned char string[5]; int baudrateConst; if (!uh_is_initialized) { start_thread(); } if (!uh_is_initialized) { return -1; } baudrateConst = 11059200 / baud ; string[0] = 0x01; string[1] = baudrateConst & 0xff ; string[2] = baudrateConst / 256 ; switch (stopbits) { case 1: string[3] = 0x00; break; case 2: string[3] = 0x40; break; default: return -1; } if (rtscts) { string[3] |= 0x10; } switch (databits) { case 5: break; case 6: string[3] |= 0x20; break; case 7: string[3] |= 0x40; break; case 8: string[3] |= 0x60; break; default: return -1; } string[4] = 0x81; writeControl(string, 5); uh_radio_in_use = 1; return uh_radio_pair[1]; }
uint8_t LCD_Low_Level::receive(uint8_t rs_bit) { writeControl(rs_bit, 1); int data = 0; if (_display_function & LCD_8BitMode) { data = read8bits(); } else { data = (read4bits() & 0x0F) << 4; data = data | (read4bits() & 0x0F); } return data; }
void Motor::setPitch(int pitch) { /* Limit the pitch value to valid interval to prevent motor breakage: */ if(pitch<-35) pitch=-35; if(pitch>55) pitch=55; /* Convert the pitch value to unsigned int: */ if(pitch<0) pitch+=65536; /* Write a pitch control message: */ writeControl(0x40,0x31,pitch,0x0000,0,0); }
/** * Set register value * @param name - register name * @param val - new value */ void SCPI_RegSet(scpi_t * context, scpi_reg_name_t name, scpi_reg_val_t val) { scpi_bool_t srq = FALSE; scpi_reg_val_t mask; scpi_reg_val_t old_val; if ((name >= SCPI_REG_COUNT) || (context->registers == NULL)) { return; } /* store old register value */ old_val = context->registers[name]; /* set register value */ context->registers[name] = val; /** @TODO: remove recutsion */ switch (name) { case SCPI_REG_STB: mask = SCPI_RegGet(context, SCPI_REG_SRE); mask &= ~STB_SRQ; if (val & mask) { val |= STB_SRQ; /* avoid sending SRQ if nothing has changed */ if (old_val != val) { srq = TRUE; } } else { val &= ~STB_SRQ; } break; case SCPI_REG_SRE: regUpdate(context, SCPI_REG_STB); break; case SCPI_REG_ESR: regUpdateSTB(context, val, SCPI_REG_ESE, STB_ESR); break; case SCPI_REG_ESE: regUpdate(context, SCPI_REG_ESR); break; case SCPI_REG_QUES: regUpdateSTB(context, val, SCPI_REG_QUESE, STB_QES); break; case SCPI_REG_QUESE: regUpdate(context, SCPI_REG_QUES); break; case SCPI_REG_OPER: regUpdateSTB(context, val, SCPI_REG_OPERE, STB_OPS); break; case SCPI_REG_OPERE: regUpdate(context, SCPI_REG_OPER); break; case SCPI_REG_COUNT: /* nothing to do */ break; } /* set updated register value */ context->registers[name] = val; if (srq) { writeControl(context, SCPI_CTRL_SRQ, SCPI_RegGet(context, SCPI_REG_STB)); } }
void Motor::setLED(Motor::LEDState newLEDState) { /* Write an LED control message: */ writeControl(0x40,0x06,newLEDState,0x0000,0,0); }
//Hides the characters on the screen. Can be unhidden again with lcdOn(). void lcdOff() { writeControl(0x08); }
//Shows the characters on the screen. void lcdOn() { writeControl(0x0C); }
//Clears all characters on the display and resets the cursor to the home position. void clearScreen() { writeControl(0x01); delayUs(3300); }
bool TinyAmixerControl::accessHW(bool receive, std::string &error) { CAutoLog autoLog(getConfigurableElement(), "ALSA", isDebugEnabled()); // Mixer handle struct mixer *mixer; // Mixer control handle struct mixer_ctl *mixerControl; uint32_t elementCount; std::string controlName = getControlName(); // Debug conditionnaly enabled in XML logControlInfo(receive); // Check parameter type is ok (deferred error, no exceptions available :-() if (!isTypeSupported()) { error = "Parameter type not supported."; return false; } // Check card number int32_t cardIndex = getCardNumber(); if (cardIndex < 0) { error = "Card " + getCardName() + " not found. Error: " + strerror(-cardIndex); return false; } // Open alsa mixer // getMixerHandle is non-const; we need to forcefully remove the constness // then, we need to cast the generic subsystem into a TinyAlsaSubsystem. mixer = static_cast<TinyAlsaSubsystem *>( const_cast<CSubsystem *>(getSubsystem()))->getMixerHandle(cardIndex); if (!mixer) { error = "Failed to open mixer for card: " + getCardName(); return false; } // Get control handle if (isdigit(controlName[0])) { mixerControl = mixer_get_ctl(mixer, asInteger(controlName)); } else { mixerControl = mixer_get_ctl_by_name(mixer, controlName.c_str()); } // Check control has been found if (!mixerControl) { error = "Failed to open mixer control: " + controlName; return false; } // Get element count elementCount = getNumValues(mixerControl); uint32_t scalarSize = getScalarSize(); // Check available size if (elementCount * scalarSize != getSize()) { error = "ALSA: Control element count (" + asString(elementCount) + ") and configurable scalar element count (" + asString(getSize() / scalarSize) + ") mismatch"; return false; } // Read/Write element bool success; if (receive) { success = readControl(mixerControl, elementCount, error); } else { success = writeControl(mixerControl, elementCount, error); } return success; }
/* * If we do not have pthreads, we cannot use the microham device. * This is so because we have to digest unsolicited messages * (e.g. voltage change) and since we have to send periodic * heartbeats. * Nevertheless, the program should compile well even we we do not * have pthreads, in this case start_thread is a dummy since uh_is_initialized * is never set. * * If we do not have socketpair(), the same thing applies. * * If we do not have select(), then the read thread cannot work so we * do not spawn it. */ static void start_thread() { #if defined(HAVE_PTHREAD) && defined(HAVE_SOCKETPAIR) && defined(HAVE_SELECT) /* * Find a microHam device and open serial port to it. * If successful, create sockets for doing I/O from within hamlib * and start a thread to listen to the "other ends" of the sockets */ int ret, fail; unsigned char buf[4]; pthread_attr_t attr; if (uh_is_initialized) { return; // PARANOIA: this should not happen } finddevices(); if (uh_device_fd < 0) { MYERROR("Could not open any microHam device.\n"); return; } // Create socket pairs if (socketpair(AF_UNIX, SOCK_STREAM, 0, uh_radio_pair) < 0) { perror("RadioPair:"); return; } if (socketpair(AF_UNIX, SOCK_STREAM, 0, uh_ptt_pair) < 0) { perror("PTTPair:"); return; } if (socketpair(AF_UNIX, SOCK_STREAM, 0, uh_wkey_pair) < 0) { perror("WkeyPair:"); return; } DEBUG("RADIO sockets: server=%d client=%d\n", uh_radio_pair[0], uh_radio_pair[1]); DEBUG("PTT sockets: server=%d client=%d\n", uh_ptt_pair[0], uh_ptt_pair[1]); DEBUG("WinKey sockets: server=%d client=%d\n", uh_wkey_pair[0], uh_wkey_pair[1]); // // Make the sockets nonblocking // First try if we can set flags, then do set the flags // fail = 0; ret = fcntl(uh_radio_pair[0], F_GETFL, 0); if (ret != -1) { ret = fcntl(uh_radio_pair[0], F_SETFL, ret | O_NONBLOCK); } if (ret == -1) { fail = 1; } ret = fcntl(uh_ptt_pair[0], F_GETFL, 0); if (ret != -1) { ret = fcntl(uh_ptt_pair[0], F_SETFL, ret | O_NONBLOCK); } if (ret == -1) { fail = 1; } ret = fcntl(uh_wkey_pair[0], F_GETFL, 0); if (ret != -1) { ret = fcntl(uh_wkey_pair[0], F_SETFL, ret | O_NONBLOCK); } if (ret == -1) { fail = 1; } ret = fcntl(uh_radio_pair[1], F_GETFL, 0); if (ret != -1) { ret = fcntl(uh_radio_pair[1], F_SETFL, ret | O_NONBLOCK); } if (ret == -1) { fail = 1; } ret = fcntl(uh_ptt_pair[1], F_GETFL, 0); if (ret != -1) { ret = fcntl(uh_ptt_pair[1], F_SETFL, ret | O_NONBLOCK); } if (ret == -1) { fail = 1; } ret = fcntl(uh_wkey_pair[1], F_GETFL, 0); if (ret != -1) { ret = fcntl(uh_wkey_pair[1], F_SETFL, ret | O_NONBLOCK); } if (ret == -1) { fail = 1; } // // If something went wrong, close everything and return // if (fail) { close_all_files(); return; } // drain input from microHam device while (read(uh_device_fd, buf, 1) > 0) { // do_nothing } uh_is_initialized = 1; starttime = time(NULL); // Do some heartbeats to sync-in heartbeat(); heartbeat(); heartbeat(); // Set keyer mode to DIGITAL buf[0] = 0x0A; buf[1] = 0x03; buf[2] = 0x8a; writeControl(buf, 3); // Start background thread reading the microham device and the sockets pthread_attr_init(&attr); ret = pthread_create(&readthread, &attr, read_device, NULL); if (ret != 0) { MYERROR("Could not start read_device thread\n"); close_all_files(); uh_is_initialized = 0; return; } TRACE("Started daemonized thread reading microHam\n"); #endif // if we do not have pthreads, this function does nothing. }
//Moves the LCD cursor to the beginning of the second line of the display (row 1). void lowerLine(void) { writeControl(SECOND_LINE); }