static void seromap_setsleep(uintptr_t *port, uint8_t mode, uint8_t wakeup) { set_port(port[OMAP_UART_EFR], OMAP_EFR_ENHANCED, OMAP_EFR_ENHANCED); // Set enhanced bit set_port(port[OMAP_UART_IER], OMAP_IER_SLEEP, mode); // Set sleep mode set_port(port[OMAP_UART_EFR], OMAP_EFR_ENHANCED, 0); // clear enhanced bit set_port(port[OMAP_UART_SCR], OMAP_SCR_WAKEUPEN, wakeup); // Set wakeup interrupt }
static void seromap_enable(DEV_OMAP *dev, int enable) { uintptr_t *port = dev->port; write_omap(port[OMAP_UART_LCR], 0x80); if (!enable) { atomic_set(&dev->pwm_flag, SEROMAP_PWM_PAGED); // If HW flow control is ON, assert the RTS line if (dev->tty.c_cflag & IHFLOW) set_port(port[OMAP_UART_MCR], OMAP_MCR_DTR|OMAP_MCR_RTS, 0); while (!(read_omap(port[OMAP_UART_LSR]) & OMAP_LSR_TSRE)) ; nanospin_ns(1000000); // pause for 1ms write_omap(port[OMAP_UART_MDR1], 0x07); write_omap(port[OMAP_UART_DLL], 0xFF); write_omap(port[OMAP_UART_DLH], 0xFF); } else { write_omap(port[OMAP_UART_DLL], dev->brd); write_omap(port[OMAP_UART_DLH], (dev->brd >> 8) & 0xff); write_omap(port[OMAP_UART_MDR1], 0x00); // If HW flow control is ON, de-assert the RTS line if(dev->tty.c_cflag & IHFLOW) set_port(port[OMAP_UART_MCR], OMAP_MCR_DTR|OMAP_MCR_RTS, OMAP_MCR_DTR|OMAP_MCR_RTS); // Allow data transmission to resume atomic_clr(&dev->pwm_flag, SEROMAP_PWM_PAGED); } write_omap(port[OMAP_UART_LCR], dev->lcr); }
void pulse_clock() { set_port(TCK,0); set_port(TCK,1); _delay_us(1000); #ifdef DEBUG_MODE // LOG_DEBUG("M=%d I=%d",(out_word&TMS)?1:0,(out_word&TDI)?1:0); #endif set_port(TCK,0); }
/* Wait at least the specified number of microsec. */ void delay(long microsec) { // _delay_ms(microsec>>12); set_port(TCK,0); while (--microsec > 0) { set_port(TCK,1); _delay_us(1); set_port(TCK,0); _delay_us(1); } }
int natt_float_ports(struct sockaddr *remote, struct sockaddr *local, uint16_t port) { if (!set_port(remote, port)) { return -1; } if (!set_port(local, port)) { return -1; } return 0; }
int main(int argc,char* argv[]) { int port_fd; int len; char recv_buf[9]; int i; if(argc!=3){ printf("Usage: %s /dev/ttySn 0(send data)/1(receive data)\n",argv[0]); return -1; } port_fd=open_port(argv[1]); if(port_fd==-1){ printf("Program Exit\n"); return -1; } //设置串口通信参数 struct port_info info; info.baud_rate=9600; info.data_bits=8; info.flow_ctrl=2; info.port_fd=port_fd; info.stop_bit=1; info.parity=0; if(set_port(&info)==-1){ printf("Program Exit\n"); return -1; } if(strcmp(argv[2],"0")==0){ for(i=0;i<10;i++){ len=send_data(port_fd,"Test Data",9); if(len>0) printf("%d send data successfully\n",i); else printf("send data failed\n"); sleep(2); } close_port(port_fd); }else{ while(1){ len=recv_data(port_fd,recv_buf,9); if(len>0){ for(i=0;i<len;i++) printf("receive data is %s\n",recv_buf); }else printf("cannot receive data\n"); sleep(2); } } return 0; }
int main(void) { init(); // set port to initial state depending on ACO set_port(); // reset ACIF to not to trigger interrupt immediately after sei #ifdef PROC_at90s4433 ACSR = _BV(AINBG) | _BV(ACIE) | _BV(ACI); #else #ifdef PROC_at90s8515 ACSR = _BV(ACIE) | _BV(ACI); #else ACSR = _BV(ACBG) | _BV(ACIE) | _BV(ACI); #endif #endif // enable interrupts sei(); do { in_loop = 1; } while(1); // do forever }
int main(){ struct addrinfo hints; struct addrinfo *result; char port_no[8], server_address[30], buffer[MAX_BUFLEN]; int status; int socket_fd; // socket file descriptor log_init(l, "../"); set_port(port_no); set_server(server_address); //ensuring hints is empty and calling getaddrinfo() memset(&hints, 0, sizeof(struct addrinfo)); //filling in hints with required values hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; if((status = getaddrinfo(server_address, port_no, &hints, &result ))!=0){ log_error(errno, gai_strerror(status)); } if((socket_fd = socket(result->ai_family, result->ai_socktype, result->ai_protocol)) == -1) { log_error(errno, "Error creating socket to server."); } fprintf(l, "%d\n", result->ai_addrlen); if(connect(socket_fd, result->ai_addr, result->ai_addrlen)==-1){ log_error(errno, "Error connecting!\n"); } // sending sample data to buffer strcpy(buffer,"*****@*****.**"); write(socket_fd, buffer, MAX_BUFLEN); }
void SetPGDDir(uchar f) { #if 0 int dirb = (1<<PGC) | (1<<PGM) | (1<<MCLR); if(f) dirb |= (1<<PGD); set_port(Ddrb ,dirb); #else // PIC if(f) { dirPGD=0; // out }else{ dirPGD=1; // in } /* int dirc = (1<<PGM) | (1<<MCLR); int dirb = (1<<PGC) ; if(f) dirb |= (1<<PGD); set_port(Ddrb ,dirb ^ 0xff); set_port(Ddrc ,dirc ^ 0xff); */ #endif }
void omap_clock_enable(DEV_OMAP* dev, clk_enable_t clk_cfg) { int enable_rc = 0; int functional_rc = 0; /* Our idle state can be changed by the ISR so we must use a spinlock */ InterruptLock(&dev->idle_spinlock); /* Only enable clocks if they aren't enabled already */ if (dev->idle == 0) { goto done; } if (dev->clkctrl_base) { /* Enable the clock */ out32(dev->clkctrl_base, OMAP_CLKCTRL_MODMODE_ENABLE); /* Wait for the module mode to have been written */ enable_rc = poll_for_condition(dev->clkctrl_base, OMAP_CLKCTRL_MODMODE_MASK, OMAP_CLKCTRL_MODMODE_ENABLE); /* Wait for the module idle status to report "fully functional" */ functional_rc = poll_for_condition(dev->clkctrl_base, OMAP_CLKCTRL_IDLEST_MASK, OMAP_CLKCTRL_IDLEST_FUNCTIONAL); /* Re-configure clock if specified otherwise simply skip it */ if (clk_cfg != clk_enable_skip) { /* Set the idle mode to smart idle with wake up */ set_port(dev->port[OMAP_UART_SYSC], OMAP_UART_SYSC_IDLEMODE_MASK, clk_cfg); } /* Enable the CTS wakeup */ write_omap(dev->port[OMAP_UART_WER], OMAP_UART_WER_CTS_ENABLE); /* Indicate clocks are enabled */ dev->idle = 0; } done: #ifdef WINBT /* clear CTS debounce timer and OHW_PAGED flag */ if (dev->tty.un.s.spare_tmr > 0) { dev->tty.un.s.spare_tmr = 0; if (dev->tty.flags & OHW_PAGED) atomic_clr (&dev->tty.flags, OHW_PAGED); } #endif omap_uart_ctx_restore(dev); InterruptUnlock(&dev->idle_spinlock); /* Don't slog while interrupts are disabled - otherwise slogf() will re-enable interrupts */ if (enable_rc) { slogf(_SLOG_SETCODE(_SLOGC_CHAR, 0), _SLOG_ERROR, "%s: Failed to set module mode to 'enabled'", __FUNCTION__); } if (functional_rc) { slogf(_SLOG_SETCODE(_SLOGC_CHAR, 0), _SLOG_ERROR, "%s: Module failed to report 'fully functional'", __FUNCTION__); } }
/************************************************************************** * to be called if memory full (out of buffers) * * It will write the code 253 to the trace. * It will morse code "MEM". * It will then turn on two LEDs (color=purple + led2) and then halt. **************************************************************************/ void bufferOverflow(void) { TRACE(253); beeps("-- . --"); pri_rgb_led_on(true, false, true); set_port(LED1); sleep_mode(); }
static void clear_device(const uintptr_t *port) { write_omap(port[OMAP_UART_IER], 0); // Disable all interrupts /* Clear FIFOs */ set_port(port[OMAP_UART_FCR], OMAP_FCR_RXCLR | OMAP_FCR_TXCLR, OMAP_FCR_RXCLR | OMAP_FCR_TXCLR); read_omap(port[OMAP_UART_LSR]); // Clear Line Status Interrupt read_omap(port[OMAP_UART_MSR]); // Clear Modem Interrupt }
/** * ソケット接続 * * @return ソケット */ int server_sock(void) { struct sockaddr_in addr; /* ソケットアドレス情報構造体 */ int retval = 0; /* 戻り値 */ int optval = 0; /* オプション */ int sock = -1; /* ソケット */ dbglog("start"); /* 初期化 */ (void)memset(&addr, 0, sizeof(struct sockaddr_in)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = htonl(INADDR_ANY); /* ポート番号またはサービス名を設定 */ if (set_port(&addr, portno) < 0) return EX_NG; /* ソケット生成 */ sock = socket(AF_INET, SOCK_STREAM, 0); if (sock < 0) { outlog("sock=%d", sock); return EX_NG; } /* ソケットオプション */ optval = 1; /* 二値オプション有効 */ retval = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, (socklen_t)sizeof(int)); if (retval < 0) { outlog("setsockopt=%d, sock=%d", retval, sock); goto error_handler; } /* ソケットにアドレスを指定 */ retval = bind(sock, (struct sockaddr *)&addr, (socklen_t)sizeof(addr)); if (retval < 0) { if (errno == EADDRINUSE) (void)fprintf(stderr, "Address already in use\n"); outlog("bind=%d, sock=%d", retval, sock); goto error_handler; } /* アクセスバックログの指定 */ retval = listen(sock, SOMAXCONN); if (retval < 0) { outlog("listen=%d, sock=%d", retval, sock); goto error_handler; } return sock; error_handler: close_sock(&sock); return EX_NG; }
void init_package_head(ap_package_t *pkt, U8 data_type,U8 src_addr, U8 dst_addr, U8 port, U8 ttl, U8 type) { memset(pkt, 0, sizeof(ap_package_t)); set_src_addr(pkt, src_addr); set_dst_addr(pkt, dst_addr); set_port(pkt, port); set_ttl(pkt, ttl);//赋值为7 set_type(pkt, type);//type传入参数为0 set_CoS(pkt,data_type); }
void serial_init(){ if((fd_serial = open_serialport(serialPort)) == -1){ perror("Open port"); return -1; } if( set_port(fd_serial,serialspeed,8,'N',1) == -1){ perror("Set_Port"); return -1; } }
const bool SM_Net::create ( const std::string &new_url ) { if( ! check_url( new_url ) ) { SM_Util::msg_err( "Error: could not identify URL." ); show_error( "URL Check", "Could not identify URL." , false ); return false; } int find_return = new_url.find( "http://" ); /* http */ if( find_return == 0 ) sm_protocol = 0; else { find_return = new_url.find( "ftp://" ); /* ftp */ if( find_return == 0 ) sm_protocol = 1; else { SM_Util::msg_err( "Error: network protocol not supported." ); show_error( "URL Check", "Network protocol\nnot supported." , false ); sm_protocol = 2; return false; } } if ( ! set_url( new_url ) ) { SM_Util::msg_err( "Error: could not define url." ); show_error( "URL Check", "Could not define url." , false ); return false; } if ( ! set_port( new_url ) ) { SM_Util::msg_err( "Error: could not define port." ); show_error( "Port Check", "Could not define port." , false ); return false; } if ( ! set_address( new_url ) ) { SM_Util::msg_err( "Error: could not define address." ); show_error( "Address Check", "Could not define address." , false ); return false; } if ( ! set_fileName( new_url ) ) { SM_Util::msg_err( "Error: could not define file name." ); show_error( "URL File Check", "Could not define\nfile name." , false ); return false; } return true; }
void getset_init (void) { set_port (1); set_verbose (0); set_host (0); set_plog (0); set_pass_plugin (0); set_http_pass_plugin (0); }
void condor_sockaddr::convert_to_ipv6() { // only ipv4 addressn can be converted if (!is_ipv4()) return; in6_addr addr = to_ipv6_address(); unsigned short port = get_port(); clear(); set_ipv6(); set_port(port); v6.sin6_addr = addr; }
/* * Finish initialization of the pocket structure. */ void BSOCK::fin_init(JCR * jcr, int sockfd, const char *who, const char *host, int port, struct sockaddr *lclient_addr) { Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port); m_fd = sockfd; set_who(bstrdup(who)); set_host(bstrdup(host)); set_port(port); memcpy(&client_addr, lclient_addr, sizeof(client_addr)); set_jcr(jcr); }
void gps_init(Stream *outstr) { cond_init(&wait_gps); monitor_pos = monitor_raw = false; uint16_t baud; GET_PARAM(GPS_BAUD, &baud); in = uart_rx_init(baud, FALSE); out = outstr; THREAD_START(nmeaListener, STACK_GPSLISTENER); make_output(GPSON); set_port(GPSON); }
/* * Connect to the first address of each of our peers in non-blocking mode. */ static void connect_to_peers(void) { struct node *node; for (node = nodes; node; node = node->next) { struct sockaddr_storage src, dst; struct addr *src_addr = local_node->addr; struct addr *dst_addr = node->addr; int fd; if (node == local_node) continue; memset(&src, 0, sizeof(dst)); memcpy(&src, src_addr->sa, src_addr->sa_len); set_port(&src, 0); memset(&dst, 0, sizeof(dst)); memcpy(&dst, dst_addr->sa, dst_addr->sa_len); set_port(&dst, fakedlm_port); fd = socket(dst_addr->family, dst_addr->socktype | SOCK_NONBLOCK, dst_addr->protocol); if (fd == -1) fail(NULL); if (bind(fd, (struct sockaddr *)&src, src_addr->sa_len) == -1) fail(NULL); if (connect(fd, (struct sockaddr *)&dst, dst_addr->sa_len) == -1) { if (errno != EINPROGRESS) fail(NULL); node->connecting_fd = fd; add_poll_callback(&cbs, fd, POLLOUT, outgoing_connection, node); } else { /* Connections shouldn't be established immediately ... */ update_poll_callback(&cbs, fd, POLLIN, proto_read, node); add_connection(fd, node); } } }
//------------------------------------------------------------------- saliency_server_t::saliency_server_t(const char* inifile) { iniWrapper ini; //fs::path filepath(core::relative_bin_config_path); if (ini.Load(inifile)) { int port = ini.GetInt("server:port", 30307); set_port(port); } register_(); }
static int save_port(int sockfd, const char *name) { sockaddr_t addr; socklen_t size = sizeof(addr); if (getsockname(sockfd, (struct sockaddr *)&addr, &size) != 0) return -1; if (set_port(name, ntohs(addr.sin_port)) < 0) return -1; return 0; }
tcp_server_t::tcp_server_t(scheduler_ptr_t scheduler, std::shared_ptr<tcp_handler_t> handler, uint16_t port, config_t config) : scheduler_(scheduler), handler_(handler), config_(config), shutdown_(false) { auto addr = inet_address_t::resolve_ip("localhost"); addr.set_port(port); accept_socket_ = addr.bind(); accept_fiber_ = scheduler_->start(&tcp_server_t::accept_loop, this); }
/** * Funktion wertet Startparameter aus * param argc - Anzahl der Startparameter * param argv - Startparameter */ void process_commands(int argc, char** argv) { debugPrint("Parsing command line options..."); // Standard Port 8111 char* server_port = { "8111" }; const char* short_options = "hvp:c"; struct option long_options[] = { { "help", no_argument, 0, 'h' }, { "verbose", no_argument, 0, 'v' }, { "port", required_argument, 0, 'p' }, { "catalog", no_argument, 0, 'c' }, { NULL, 0, NULL, 0 } }; int opt_index = 0; int loop = 1; while(loop != 0){ int opt = getopt_long(argc, argv, short_options, long_options, &opt_index); switch(opt){ // zeige Hilfe case 'h': show_help(); exit(1); break; // Verbose case 'v': debugEnable(); infoPrint("debug Ausgabe aktiviert."); break; // Port case 'p': server_port = optarg; break; // Katalog case 'c': catalog_dir = optarg; break; case -1: loop = 0; break; // Option nicht bekannt default: break; } } // Setze Port set_port(server_port); }
int main( int argc, char *argv[] ) { int i; int len; int port_fd; char recv_buf[MAX_BUF_LEN]; struct port_info info; if ( argc != 2 ) { fprintf( stdout, "%s /dev/ttySn\n", argv[0] ); return -1; } port_fd = open_port( argv[1] ); if ( port_fd == -1 ) { fprintf( stderr, "open_port err" ); return -1; } /* 设置串口参数 */ info.baud_rate = 9600; info.data_bits = 8; info.flow_ctrl = 2; info.port_fd = port_fd; info.stop_bit = 1; info.parity = 0; if ( set_port( &info ) == -1 ) { fprintf( stderr, "set_port err\n" ); close(port_fd); return -1; } /* 接受数据 */ while (1) { len = recv_data( port_fd, recv_buf, MAX_BUF_LEN ); if ( len > 0 ) { for ( i = 0; i < len; i++ ) { fprintf( stdout, "recv data is: %s\n", recv_buf ); } } else { fprintf( stderr, "recv data failed\n" ); } sleep(2); } close_port(port_fd); return 0; }
Connection::Connection(void) : init_ok_(0), last_recv_time_(time(NULL)), last_send_time_(time(NULL)), last_error_(0), auto_release_(0), state_(CLOSED), default_event_handler_("ConnDefHandler"), connection_manager_(NULL), event_handler_(&default_event_handler_) { set_ip(0U); set_port(0U); set_protocol("tcp"); }
void register_service(std::string const &name, int port, std::map<std::string, std::string> const &txt) { directoryd::ServiceRequest request; request.set_type(directoryd::REGISTER); auto *r = request.mutable_register_(); auto l = r->add_location(); l->set_port(port); l->set_type("_hotdec._tcp"); r->set_name(name); for (auto &t : txt) { auto txtfield = r->add_txt(); txtfield->set_key(t.first); txtfield->set_value(t.second); } zframe_t *sf = zframe_new(NULL, request.ByteSize()); assert (sf != NULL); request.SerializeToArray(zframe_data(sf),zframe_size(sf)); string buffer; if (debug && TextFormat::PrintToString(request, &buffer)) { fprintf(stderr, "request: %s\n", buffer.c_str()); } int retval = zframe_send(&sf, DDClient::instance().register_socket(), 0); assert(retval == 0); zframe_t *rf = zframe_recv (DDClient::instance().register_socket()); directoryd::ServiceReply reply; reply.ParseFromArray(zframe_data(rf),zframe_size(rf)); if (debug && TextFormat::PrintToString(reply, &buffer)) { fprintf(stderr, "reply: %s\n", buffer.c_str()); } zframe_destroy(&rf); if (reply.type() != directoryd::REGISTER) { throw RegistrationError("Got back incorrect message type when trying to register."); } if (reply.success() != true) { throw RegistrationError(reply.result()); } RegistrationManager::instance().add(name); }
RASServer::RASServer(int port) { bzero((char*) &address_info, sizeof(address_info)); address_info.sin_family = AF_INET; address_info.sin_addr.s_addr = INADDR_ANY; if(port != -1) set_port(port); signal(SIGCHLD, on_child_term); int shmid = shm_open(SHMNAME, O_CREAT|O_RDWR, 0744); ftruncate(shmid, CLIENTNO*sizeof(int)); ids = (int*) mmap(NULL, (CLIENTNO+1)*sizeof(int), PROT_READ|PROT_WRITE, MAP_SHARED, shmid, 0); memset(ids, 0, (CLIENTNO+1)*sizeof(int)); ids[0] = CLIENTNO; }
int main(int argc, char **argv) { printf("*** 16 channel PWM/Servo test program 4 ***\n"); int file; char filename[20]; char wr_buf[10]; int addr = PWM_16CH; int c; file = open_device(filename); set_port(file, addr); printf("Enter an angel: "); scanf("%d",&c); while (c > 0) { if (c > 179 || c < 1) { c = 90; } // calculate the corresponding value for the entered angel float value = (240 - c) / 0.4; int int_val = (int)value; uint16_t val_hex = (uint16_t)int_val; // fix lo/hi byte uint8_t lo_byte = val_hex & 0xff; uint8_t hi_byte = val_hex>>8 & 0xff; // write to registers wr_buf[0] = LED0_OFF_L; wr_buf[1] = lo_byte; write_byte(file,wr_buf); wr_buf[0] = LED0_OFF_H; wr_buf[1] = hi_byte; write_byte(file,wr_buf); printf("Enter an angel: "); scanf("%d",&c); } return 0; }