static int posix_serial_close(struct posix_serial* s)
{
int ret = 0;
if(NULL == s) {
ret = -SERIAL_ERR_INPUT_NULL;
goto POSIX_SERIAL_CLOSE_INPUT_ERROR;
}
if(s->sb->is_open(s->sb)) {
/* push all tx buffer to serial */
s->drain(s);
/* reconfig oldtio */
tcsetattr(s->fd, TCSANOW, &s->oldtio);
/* clean serial open flag */
s->sb->clean_is_open(s->sb);
/* closd fd and set fd to 0 */
close(s->fd);
s->fd = 0;
/* free port name */
s->sb->clean_port(s->sb);
/* free serial_base */
serial_free(s->sb);
/* free posix_serial */
serial_free(s);
}
else {
printf("%s: posix serial(%s) is not open, close failed.\n", __func__, s->sb->get_port(s->sb));
}
return 0;
POSIX_SERIAL_CLOSE_INPUT_ERROR:
return ret;
}
// Stop listening. Returns true if we were actually listening.
bool SoftwareSerial::stopListening()
{
serial_free((serial_t *)pUART);
free( (serial_t *)pUART );
pUART = NULL;
return true;
}
/**
* A way of dynamically configuring the serial instance to use pins other than USBTX and USBRX.
*
* @param tx the new transmission pin.
*
* @param rx the new reception pin.
*
* @return MICROBIT_SERIAL_IN_USE if another fiber is currently transmitting or receiving, otherwise MICROBIT_OK.
*/
int MicroBitSerial::redirect(PinName tx, PinName rx)
{
if(txInUse() || rxInUse())
return MICROBIT_SERIAL_IN_USE;
lockTx();
lockRx();
if(txBufferedSize() > 0)
detach(Serial::TxIrq);
detach(Serial::RxIrq);
serial_free(&_serial);
serial_init(&_serial, tx, rx);
attach(this, &MicroBitSerial::dataReceived, Serial::RxIrq);
if(txBufferedSize() > 0)
attach(this, &MicroBitSerial::dataWritten, Serial::TxIrq);
this->baud(this->baudrate);
unlockRx();
unlockTx();
return MICROBIT_OK;
}
int uart_close(uart_socket_t *u)
{
if(!u){
uart_printf("uart_close(): u is NULL!\r\n");
return -1;
}
/* Close uart socket */
if(lwip_close(u->fd) == -1){
uart_printf("%s(): close uart failed!", __func__);
}
/* Delete uart_action task */
u->fd = -1;
RtlUpSema(&u->action_sema);
RtlMsleepOS(20);
/* Free uart related semaphore */
RtlFreeSema(&u->action_sema);
RtlFreeSema(&u->tx_sema);
RtlFreeSema(&u->dma_tx_sema);
/* Free serial */
serial_free(&u->sobj);
RtlMfree((u8 *)u, sizeof(uart_socket_t));
return 0;
}
int main(void)
{
serial_handle_t *s0;
if (serial_open(&s0, DEV, BAUDRATE, OPTS, cb_ttyusb0) < 0) {
fprintf(stderr, "serial open(%s): %s\n", DEV, strerror(errno));
exit(EXIT_FAILURE);
}
while (!serial_alive(s0))
sleep(3);
serial_free(&s0);
return 0;
}
IRSendRev::~IRSendRev() {
if (pGpioIrqRecv != NULL) {
free(pGpioIrqRecv);
pGpioIrqRecv = NULL;
}
if (pTimerRecv != NULL) {
free(pTimerRecv);
pTimerRecv = NULL;
}
if (pUART != NULL) {
serial_free((serial_t *)pUART);
free(pUART);
pUART = NULL;
}
}
/*
global functions
*/
struct posix_serial* posix_serial_port_init(posix_serial_init_t* psp)
{
serial_init_t* sp = NULL;
struct posix_serial* ps = NULL;
if (NULL==psp) {
printf("fail1\n");
goto POSIX_SERIAL_PORT_INIT_INPUT_ERROR;
}
/* malloc a posix_serial port */
ps = (struct posix_serial*)serial_malloc(1*sizeof(struct posix_serial));
if(NULL==ps) {
printf("fail2\n");
goto POSIX_SERIAL_PORT_INIT_MALLOC_PS_ERROR;
}
/* copy basic serial init values and ini basic serial */
sp = &psp->sp;
ps->sb = base_serial_port_init(sp);
if(NULL==ps->sb) {
printf("fail3\n");
goto POSIX_SERIAL_PORT_INIT_INIT_SB_ERROR;
}
/* init all posix serial parameters */
ps->fd = 0;
ps->open = posix_serial_open;
ps->config_port = posix_serial_config_port;
ps->close = posix_serial_close;
ps->read_in_wait = posix_serial_read_in_wait;
ps->read = posix_serial_read;
ps->write_in_wait = posix_serial_write_in_wait;
ps->write = posix_serial_write;
ps->drain = posix_serial_drain;
ps->flush_input = posix_serial_flush_input;
ps->flush_output = posix_serial_flush_output;
/* return posix serial */
return ps;
POSIX_SERIAL_PORT_INIT_INIT_SB_ERROR:
serial_free(ps);
POSIX_SERIAL_PORT_INIT_MALLOC_PS_ERROR:
POSIX_SERIAL_PORT_INIT_INPUT_ERROR:
return NULL;
}
// try to send a message, return false if it won't fit in the serial tx buffer
static bool mavlink_try_send_message(mavlink_channel_t chan, enum ap_message id, uint16_t packet_drops)
{
int16_t payload_space = serial_free();
if (telemetry_delayed(chan)) {
return false;
}
switch(id) {
case MSG_HEARTBEAT:
CHECK_PAYLOAD_SIZE(HEARTBEAT);
send_heartbeat(chan);
break;
case MSG_ATTITUDE:
CHECK_PAYLOAD_SIZE(ATTITUDE);
send_attitude(chan);
break;
case MSG_LOCATION:
CHECK_PAYLOAD_SIZE(GLOBAL_POSITION_INT);
send_location(chan);
break;
case MSG_AHRS:
CHECK_PAYLOAD_SIZE(AHRS);
send_ahrs(chan);
break;
case MSG_STATUSTEXT:
CHECK_PAYLOAD_SIZE(STATUSTEXT);
send_statustext(chan);
break;
default:
break;
}
return true;
}
static void serial_out(const u16 port, const char value)
{
while (!serial_free(port));
io_outb(port, value);
}
int net_controller_tick(controller *ctrl, int ticks, ctrl_event **ev) {
ENetEvent event;
wtf *data = ctrl->data;
ENetHost *host = data->host;
ENetPeer *peer = data->peer;
serial *ser;
/*int handled = 0;*/
while (enet_host_service(host, &event, 0) > 0) {
switch (event.type) {
case ENET_EVENT_TYPE_RECEIVE:
ser = malloc(sizeof(serial));
serial_create(ser);
ser->data = malloc(event.packet->dataLength);
ser->len = event.packet->dataLength;
memcpy(ser->data, event.packet->data, event.packet->dataLength);
switch(serial_read_int8(ser)) {
case EVENT_TYPE_ACTION:
{
// dispatch keypress to scene
int action = serial_read_int16(ser);
controller_cmd(ctrl, action, ev);
/*handled = 1;*/
serial_free(ser);
free(ser);
}
break;
case EVENT_TYPE_HB:
{
// got a tick
int id = serial_read_int8(ser);
if (id == data->id) {
int start = serial_read_int32(ser);
int peerticks = serial_read_int32(ser);
int newrtt = abs(start - ticks);
data->rttbuf[data->rttpos++] = newrtt;
if (data->rttpos >= 100) {
data->rttpos = 0;
data->rttfilled = 1;
}
if (data->rttfilled == 1) {
ctrl->rtt = avg_rtt(data->rttbuf, 100);
data->tick_offset = (peerticks + (ctrl->rtt/2)) - ticks;
/*DEBUG("I am %d ticks away from server: %d %d", data->tick_offset, ticks, peerticks);*/
}
data->outstanding_hb = 0;
data->last_hb = ticks;
serial_free(ser);
} else {
// a heartbeat from the peer, bounce it back
ENetPacket *packet;
// write our own ticks into it
serial_write_int32(ser, ticks);
packet = enet_packet_create(ser->data, ser->len, ENET_PACKET_FLAG_UNSEQUENCED);
if (peer) {
enet_peer_send(peer, 0, packet);
enet_host_flush (host);
}
}
free(ser);
}
break;
case EVENT_TYPE_SYNC:
controller_sync(ctrl, ser, ev);
/*handled = 1;*/
break;
default:
serial_free(ser);
free(ser);
}
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
DEBUG("peer disconnected!");
data->disconnected = 1;
controller_close(ctrl, ev);
return 1; // bail the f**k out
break;
default:
break;
}
}
int tick_interval = 5;
if (data->rttfilled) {
tick_interval = 20;
}
if ((data->last_hb == -1 || ticks - data->last_hb > tick_interval) || !data->outstanding_hb) {
data->outstanding_hb = 1;
serial ser;
ENetPacket *packet;
serial_create(&ser);
serial_write_int8(&ser, EVENT_TYPE_HB);
serial_write_int8(&ser, data->id);
serial_write_int32(&ser, ticks);
packet = enet_packet_create(ser.data, ser.len, ENET_PACKET_FLAG_UNSEQUENCED);
if (peer) {
enet_peer_send(peer, 0, packet);
enet_host_flush (host);
} else {
DEBUG("peer is null~");
data->disconnected = 1;
controller_close(ctrl, ev);
}
}
/*if(!handled) {*/
/*controller_cmd(ctrl, ACT_STOP, ev);*/
/*}*/
return 0;
}
