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;
}
