void Serial::SerialImpl::setDTR (bool level) { if (is_open_ == false) { throw PortNotOpenedException ("Serial::setDTR"); } int command = TIOCM_DTR; if (level) { if (-1 == ioctl (fd_, TIOCMBIS, &command)) { stringstream ss; ss << "setDTR failed on a call to ioctl(TIOCMBIS): " << errno << " " << strerror(errno); throw(SerialException(ss.str().c_str())); } } else { if (-1 == ioctl (fd_, TIOCMBIC, &command)) { stringstream ss; ss << "setDTR failed on a call to ioctl(TIOCMBIC): " << errno << " " << strerror(errno); throw(SerialException(ss.str().c_str())); } } }
void main() { char data; //To store the character to send printf("Enter character to be sent"); //User prompt scanf("%c",&data); //User input comm.startDevice("COM2", 9600); /* “COM 2” refers to the com port in which the USB to SERIAL port is attached. It is shown by right clicking on my computer, then going to properties and then device manager 9600 is the baud-rate in bits per second */ comm.send_data(data); //The data is sent through the port comm.stopDevice(); //The device is closed down }
void Serial::SerialImpl::open () { if (port_.empty ()) { throw invalid_argument ("Empty port is invalid."); } if (is_open_ == true) { throw SerialException ("Serial port already open."); } fd_ = ::open (port_.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK); if (fd_ == -1) { switch (errno) { case EINTR: // Recurse because this is a recoverable error. open (); return; case ENFILE: case EMFILE: THROW (IOException, "Too many file handles open."); default: THROW (IOException, errno); } } reconfigurePort(); is_open_ = true; }
void Serial::SerialImpl::open () { if (port_.empty ()) { throw invalid_argument ("Empty port is invalid."); } if (is_open_ == true) { throw SerialExecption ("Serial port already open."); } fd_ = CreateFile(port_.c_str(), GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (fd_ == INVALID_HANDLE_VALUE) { DWORD errno_ = GetLastError(); stringstream ss; switch (errno_) { case ERROR_FILE_NOT_FOUND: ss << "Specified port, " << port_ << ", does not exist."; THROW (IOException, ss.str().c_str()); default: ss << "Unknown error opening the serial port: " << errno; THROW (IOException, ss.str().c_str()); } } reconfigurePort(); is_open_ = true; }
/* int c; do { c = inportb(PORT1 + 5); if (c & 1) {buffer[bufferin] = inportb(PORT1); bufferin++; if (bufferin == 1024) {bufferin = 0;}} }while (c & 1); outportb(0x20,0x20); */ EXTERNC void handle_serial() { //display("?"); unsigned int result = 0; result = inportb(COM1_PORT + INT_ID); unsigned int status; //stores the status of whatever needs checking if ((result & IID_NO_INT) != IID_NO_INT) { //interrupt pending //display("\nInterrupt pending: "); //PrintNumber(result); //display("\n"); if ((result & 0x06) == IID_MODEM) { } if ((result & 0x06) == IID_REC_STAT) { //status = inportb(COM1_PORT); } if ((result & 0x06) == IID_TRANSMIT) { } if ((result & 0x06) == IID_RECEIVED) { add_me_serial.data1 = kellogs.read_serial(); add_system_event(&add_me_serial); } } outportb(0x20,0x20); //signal end of interrupt //display("+"); }
// bii:#entry_point() void loop() { msg = serialport.read(); //read a message if(msg != "") { serialport.writeOpen(); serialport.writeString(msg); //send a message serialport.writeEnd(); if(premsg=="servo"){ int n; n = atoi(msg.c_str()); myservo.write(n); } premsg = msg; } }
void Serial::SerialImpl::sendBreak (int duration) { if (is_open_ == false) { throw PortNotOpenedException ("Serial::sendBreak"); } tcsendbreak (fd_, static_cast<int> (duration / 4)); }
void Serial::SerialImpl::flushOutput () { if (is_open_ == false) { throw PortNotOpenedException ("Serial::flushOutput"); } tcflush (fd_, TCOFLUSH); }
void Serial::SerialImpl::flush () { if (is_open_ == false) { throw PortNotOpenedException ("Serial::flush"); } tcdrain (fd_); }
void Serial::SerialImpl::flush () { if (is_open_ == false) { throw PortNotOpenedException ("Serial::flush"); } FlushFileBuffers (fd_); }
bool Serial::SerialImpl::waitForChange () { #ifndef TIOCMIWAIT while (is_open_ == true) { int status; if (-1 == ioctl (fd_, TIOCMGET, &status)) { stringstream ss; ss << "waitForChange failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno); throw(SerialException(ss.str().c_str())); } else { if (0 != (status & TIOCM_CTS) || 0 != (status & TIOCM_DSR) || 0 != (status & TIOCM_RI) || 0 != (status & TIOCM_CD)) { return true; } } usleep(1000); } return false; #else int command = (TIOCM_CD|TIOCM_DSR|TIOCM_RI|TIOCM_CTS); if (-1 == ioctl (fd_, TIOCMIWAIT, &command)) { stringstream ss; ss << "waitForDSR failed on a call to ioctl(TIOCMIWAIT): " << errno << " " << strerror(errno); throw(SerialException(ss.str().c_str())); } return true; #endif }
bool Serial::SerialImpl::getRI () { if (is_open_ == false) { throw PortNotOpenedException ("Serial::getRI"); } int status; if (-1 == ioctl (fd_, TIOCMGET, &status)) { stringstream ss; ss << "getRI failed on a call to ioctl(TIOCMGET): " << errno << " " << strerror(errno); throw(SerialException(ss.str().c_str())); } else { return 0 != (status & TIOCM_RI); } }
void Serial::SerialImpl::setBreak (bool level) { if (is_open_ == false) { throw PortNotOpenedException ("Serial::setBreak"); } if (level) { EscapeCommFunction (fd_, SETBREAK); } else { EscapeCommFunction (fd_, CLRBREAK); } }
void Serial::SerialImpl::setDTR (bool level) { if (is_open_ == false) { throw PortNotOpenedException ("Serial::setDTR"); } if (level) { EscapeCommFunction (fd_, SETDTR); } else { EscapeCommFunction (fd_, CLRDTR); } }
bool Serial::SerialImpl::getCD() { if (is_open_ == false) { throw PortNotOpenedException ("Serial::getCD"); } DWORD dwModemStatus; if (!GetCommModemStatus(fd_, &dwModemStatus)) // Error in GetCommModemStatus; THROW (IOException, "Error getting the status of the DSR line."); return (bool) (MS_RLSD_ON & dwModemStatus); }
bool Serial::SerialImpl::getRI() { if (is_open_ == false) { throw PortNotOpenedException ("Serial::getRI"); } DWORD dwModemStatus; if (!GetCommModemStatus(fd_, &dwModemStatus)) { THROW (IOException, "Error getting the status of the RI line."); } return (MS_RING_ON & dwModemStatus) != 0; }
void Serial::SerialImpl::setBreak (bool level) { if (is_open_ == false) { throw PortNotOpenedException ("Serial::setBreak"); } if (level) { if (-1 == ioctl (fd_, TIOCSBRK)) { stringstream ss; ss << "setBreak failed on a call to ioctl(TIOCSBRK): " << errno << " " << strerror(errno); throw(SerialException(ss.str().c_str())); } } else { if (-1 == ioctl (fd_, TIOCCBRK)) { stringstream ss; ss << "setBreak failed on a call to ioctl(TIOCCBRK): " << errno << " " << strerror(errno); throw(SerialException(ss.str().c_str())); } } }
size_t Serial::SerialImpl::write (const uint8_t *data, size_t length) { if (is_open_ == false) { throw PortNotOpenedException ("Serial::write"); } DWORD bytes_written; if (!WriteFile(fd_, data, static_cast<DWORD>(length), &bytes_written, NULL)) { stringstream ss; ss << "Error while writing to the serial port: " << GetLastError(); THROW (IOException, ss.str().c_str()); } return (size_t) (bytes_written); }
size_t Serial::SerialImpl::read (uint8_t *buf, size_t size) { if (!is_open_) { throw PortNotOpenedException ("Serial::read"); } DWORD bytes_read; if (!ReadFile(fd_, buf, static_cast<DWORD>(size), &bytes_read, NULL)) { stringstream ss; ss << "Error while reading from the serial port: " << GetLastError(); THROW (IOException, ss.str().c_str()); } return (size_t) (bytes_read); }
bool Serial::SerialImpl::waitForChange () { if (is_open_ == false) { throw PortNotOpenedException ("Serial::waitForChange"); } DWORD dwCommEvent = 0; if (!SetCommMask(fd_, EV_CTS | EV_DSR | EV_RING | EV_RLSD)) { // Error setting communications mask return false; } if (!WaitCommEvent(fd_, &dwCommEvent, NULL)) { // An error occurred waiting for the event. return false; } else { // Event has occurred. return true; } }
size_t Serial::SerialImpl::available () { if (!is_open_) { throw PortNotOpenedException ("Serial::available"); } DWORD dwBytesInQueue = 0; // If the port is open and the device is not NULL DWORD dwErrorFlags = 0; COMSTAT ComStat; ClearCommError (fd_, &dwErrorFlags, // 指向接收错误码的变量 &ComStat ); // 指向通讯状态缓冲区 dwBytesInQueue = (DWORD)ComStat.cbInQue; // COMSTAT结构包含串口的信息,该成员变量的值代表输入缓冲区的字节数 return (dwBytesInQueue); }
void Serial::SerialImpl::open () { if (port_.empty ()) { throw invalid_argument ("Empty port is invalid."); } if (is_open_ == true) { throw SerialException ("Serial port already open."); } // See: https://github.com/wjwwood/serial/issues/84 wstring port_with_prefix = _prefix_port_if_needed(port_); LPCWSTR lp_port = port_with_prefix.c_str(); fd_ = CreateFileW(lp_port, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (fd_ == INVALID_HANDLE_VALUE) { DWORD errno_ = GetLastError(); stringstream ss; switch (errno_) { case ERROR_FILE_NOT_FOUND: // Use this->getPort to convert to a std::string ss << "Specified port, " << this->getPort() << ", does not exist."; THROW (IOException, ss.str().c_str()); default: ss << "Unknown error opening the serial port: " << errno; THROW (IOException, ss.str().c_str()); } } reconfigurePort(); is_open_ = true; }
size_t Serial::SerialImpl::write (const uint8_t *data, size_t length) { if (is_open_ == false) { throw PortNotOpenedException ("Serial::write"); } fd_set writefds; size_t bytes_written = 0; // Calculate total timeout in milliseconds t_c + (t_m * N) long total_timeout_ms = timeout_.write_timeout_constant; total_timeout_ms += timeout_.write_timeout_multiplier * static_cast<long> (length); MillisecondTimer total_timeout(total_timeout_ms); while (bytes_written < length) { int64_t timeout_remaining_ms = total_timeout.remaining(); if (timeout_remaining_ms <= 0) { // Timed out break; } timespec timeout(timespec_from_ms(timeout_remaining_ms)); FD_ZERO (&writefds); FD_SET (fd_, &writefds); // Do the select int r = pselect (fd_ + 1, NULL, &writefds, NULL, &timeout, NULL); // Figure out what happened by looking at select's response 'r' /** Error **/ if (r < 0) { // Select was interrupted, try again if (errno == EINTR) { continue; } // Otherwise there was some error THROW (IOException, errno); } /** Timeout **/ if (r == 0) { break; } /** Port ready to write **/ if (r > 0) { // Make sure our file descriptor is in the ready to write list if (FD_ISSET (fd_, &writefds)) { // This will write some ssize_t bytes_written_now = ::write (fd_, data + bytes_written, length - bytes_written); // write should always return some data as select reported it was // ready to write when we get to this point. if (bytes_written_now < 1) { // Disconnected devices, at least on Linux, show the // behavior that they are always ready to write immediately // but writing returns nothing. throw SerialException ("device reports readiness to write but " "returned no data (device disconnected?)"); } // Update bytes_written bytes_written += static_cast<size_t> (bytes_written_now); // If bytes_written == size then we have written everything we need to if (bytes_written == length) { break; } // If bytes_written < size then we have more to write if (bytes_written < length) { continue; } // If bytes_written > size then we have over written, which shouldn't happen if (bytes_written > length) { throw SerialException ("write over wrote, too many bytes where " "written, this shouldn't happen, might be " "a logical error!"); } } // This shouldn't happen, if r > 0 our fd has to be in the list! THROW (IOException, "select reports ready to write, but our fd isn't" " in the list, this shouldn't happen!"); } } return bytes_written; }
void setup() { myservo.attach(9); serialport.init(); }
size_t Serial::SerialImpl::read (uint8_t *buf, size_t size) { // If the port is not open, throw if (!is_open_) { throw PortNotOpenedException ("Serial::read"); } size_t bytes_read = 0; // Calculate total timeout in milliseconds t_c + (t_m * N) long total_timeout_ms = timeout_.read_timeout_constant; total_timeout_ms += timeout_.read_timeout_multiplier * static_cast<long> (size); MillisecondTimer total_timeout(total_timeout_ms); // Pre-fill buffer with available bytes { ssize_t bytes_read_now = ::read (fd_, buf, size); if (bytes_read_now > 0) { bytes_read = bytes_read_now; } } while (bytes_read < size) { int64_t timeout_remaining_ms = total_timeout.remaining(); if (timeout_remaining_ms <= 0) { // Timed out break; } // Timeout for the next select is whichever is less of the remaining // total read timeout and the inter-byte timeout. uint32_t timeout = std::min(static_cast<uint32_t> (timeout_remaining_ms), timeout_.inter_byte_timeout); // Wait for the device to be readable, and then attempt to read. if (waitReadable(timeout)) { // If it's a fixed-length multi-byte read, insert a wait here so that // we can attempt to grab the whole thing in a single IO call. Skip // this wait if a non-max inter_byte_timeout is specified. if (size > 1 && timeout_.inter_byte_timeout == Timeout::max()) { size_t bytes_available = available(); if (bytes_available + bytes_read < size) { waitByteTimes(size - (bytes_available + bytes_read)); } } // This should be non-blocking returning only what is available now // Then returning so that select can block again. ssize_t bytes_read_now = ::read (fd_, buf + bytes_read, size - bytes_read); // read should always return some data as select reported it was // ready to read when we get to this point. if (bytes_read_now < 1) { // Disconnected devices, at least on Linux, show the // behavior that they are always ready to read immediately // but reading returns nothing. throw SerialException ("device reports readiness to read but " "returned no data (device disconnected?)"); } // Update bytes_read bytes_read += static_cast<size_t> (bytes_read_now); // If bytes_read == size then we have read everything we need if (bytes_read == size) { break; } // If bytes_read < size then we have more to read if (bytes_read < size) { continue; } // If bytes_read > size then we have over read, which shouldn't happen if (bytes_read > size) { throw SerialException ("read over read, too many bytes where " "read, this shouldn't happen, might be " "a logical error!"); } } } return bytes_read; }
void __irq_dma1_channel4(void) { //DMA_ClearITPendingBit(DMA1_IT_TC4); serial1.txIsr(); }
int main(void) { halInit(); chSysInit(); //kruciální řádky - odpojit jtag; nechat jenom swd - sou na nem piny pro SPI1 //premapovat SPI1 na PB3;4;5 RCC->APB2ENR |= RCC_APB2ENR_AFIOEN; AFIO->MAPR |= AFIO_MAPR_SPI1_REMAP; AFIO->MAPR |= 0b010 << 24; #if 1 spiStart(&SPID1, &config); palSetPadMode(config.ssport, config.sspad, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(SPI_SCK_PORT, SPI_SCK_PIN, SPI_SCK_MODE); palSetPadMode(SPI_MISO_PORT, SPI_MISO_PIN, SPI_MISO_MODE); palSetPadMode(SPI_MOSI_PORT, SPI_MOSI_PIN, SPI_MOSI_MODE); #else palSetPadMode(config.ssport, config.sspad, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(SPI_SCK_PORT, SPI_SCK_PIN, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(SPI_MISO_PORT, SPI_MISO_PIN, PAL_MODE_OUTPUT_PUSHPULL); palSetPadMode(SPI_MOSI_PORT, SPI_MOSI_PIN, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(config.ssport, config.sspad); palClearPad(SPI_SCK_PORT, SPI_SCK_PIN); palClearPad(SPI_MISO_PORT, SPI_MISO_PIN); palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN); palSetPad(config.ssport, config.sspad); palClearPad(config.ssport, config.sspad); palClearPad(SPI_SCK_PORT, SPI_SCK_PIN); palClearPad(SPI_MISO_PORT, SPI_MISO_PIN); palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN); palSetPad(SPI_SCK_PORT, SPI_SCK_PIN); palClearPad(config.ssport, config.sspad); palClearPad(SPI_SCK_PORT, SPI_SCK_PIN); palClearPad(SPI_MISO_PORT, SPI_MISO_PIN); palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN); palSetPad(SPI_MISO_PORT, SPI_MISO_PIN); palClearPad(config.ssport, config.sspad); palClearPad(SPI_SCK_PORT, SPI_SCK_PIN); palClearPad(SPI_MISO_PORT, SPI_MISO_PIN); palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN); palSetPad(SPI_MOSI_PORT, SPI_MOSI_PIN); palClearPad(config.ssport, config.sspad); palClearPad(SPI_SCK_PORT, SPI_SCK_PIN); palClearPad(SPI_MISO_PORT, SPI_MISO_PIN); palClearPad(SPI_MOSI_PORT, SPI_MOSI_PIN); // #endif palSetPadMode(TEST_LED_PORT, TEST_LED_PIN, PAL_MODE_INPUT); palSetPadMode(TEST_LED_PORT2, TEST_LED_PIN2, PAL_MODE_OUTPUT_PUSHPULL); palClearPad(TEST_LED_PORT, TEST_LED_PIN); palClearPad(TEST_LED_PORT2, TEST_LED_PIN2); s1.Register(); palSetPadMode(GPIOA, 2, PAL_MODE_STM32_ALTERNATE_PUSHPULL); // palSetPad(GPIOA,2); //DBGMCU->CR |= DBGMCU_CR_DBG_TIM2_STOP; pwmStart(&PWMD2, &pwmcfg); pwmEnableChannel(&PWMD2,2,PWM_PERCENTAGE_TO_WIDTH(&PWMD2,5000)); //setup watchdog DBGMCU->CR |= DBGMCU_CR_DBG_IWDG_STOP; IWDG->KR = 0x5555; IWDG->PR = 6; IWDG->RLR = 0xFFF; IWDG->KR = 0xCCCC; #if 1 ser.Init(); rf.begin(); rf.enableAckPayload(); rf.enableDynamicPayloads(); for (int i = 0; i < 5; i++) rf.openReadingPipe(i, pipe + i); rf.startListening(); #endif while (TRUE) { Scheduler::Play(); ser.Loop(); sysTime = chTimeNow(); } return 1; }