FILE*
HTTPClient::openClientFile()
{
FILE* result = fdevopen(clientWrite, clientRead);
if (result == NULL)
{
return NULL;
}
http_stream_udata* udata = (http_stream_udata*) malloc(
sizeof(http_stream_udata));
fdev_set_udata(result,udata);
udata->client = this;
udata->encode = 0;
if (connected())
{
stop();
}
if (connect())
{
return result;
}
else
{
closeStream(result);
return NULL;
}
}
void CDC_Device_CreateBlockingStream(
USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
FILE* const Stream)
{
*Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar_Blocking, _FDEV_SETUP_RW);
fdev_set_udata(Stream, CDCInterfaceInfo);
}
void CDC_Device_SendControlLineStateChange(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo)
{
if ((USB_DeviceState != DEVICE_STATE_Configured) || !(CDCInterfaceInfo->State.LineEncoding.BaudRateBPS))
return;
Endpoint_SelectEndpoint(CDCInterfaceInfo->Config.NotificationEndpointNumber);
USB_Request_Header_t Notification = (USB_Request_Header_t)
{
.bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE),
.bRequest = CDC_NOTIF_SerialState,
.wValue = CPU_TO_LE16(0),
.wIndex = CPU_TO_LE16(0),
.wLength = CPU_TO_LE16(sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost)),
};
Endpoint_Write_Stream_LE(&Notification, sizeof(USB_Request_Header_t), NULL);
Endpoint_Write_Stream_LE(&CDCInterfaceInfo->State.ControlLineStates.DeviceToHost,
sizeof(CDCInterfaceInfo->State.ControlLineStates.DeviceToHost),
NULL);
Endpoint_ClearIN();
}
#if defined(FDEV_SETUP_STREAM)
void CDC_Device_CreateStream(USB_ClassInfo_CDC_Device_t* const CDCInterfaceInfo,
FILE* const Stream)
{
*Stream = (FILE)FDEV_SETUP_STREAM(CDC_Device_putchar, CDC_Device_getchar, _FDEV_SETUP_RW);
fdev_set_udata(Stream, CDCInterfaceInfo);
}
int16_t Print::printf(const __FlashStringHelper *format, ...)
{
FILE f;
va_list ap;
fdev_setup_stream(&f, printf_putchar, NULL, _FDEV_SETUP_WRITE);
fdev_set_udata(&f, this);
va_start(ap, format);
return vfprintf_P(&f, (const char *)format, ap);
}
/* === functions =========================================================== */
int buffer_stream_init( buffer_stream_t *pbs,
void (*incb)(buffer_t *pbuf),
void (*outcb)(buffer_t *pbuf))
{
FILE *f;
f = &(pbs->bstream);
pbs->pbufin = NULL;
pbs->pbufout = NULL;
pbs->incb = incb;
pbs->outcb = outcb;
fdev_setup_stream ( f,
buffer_stream_putchar,
buffer_stream_getchar,
_FDEV_SETUP_RW);
fdev_set_udata(f, pbs);
return 0;
}
void *
ttyopen(struct devsw *devptr)
{
struct tty *iptr = &tty[devptr->dvminor];
FILE *streamPtr;
if ( (streamPtr = (FILE *)calloc(1,sizeof(FILE)) ) == (FILE *)NULL )
return 0;
fdev_setup_stream(streamPtr, stdPut, stdGet, _FDEV_SETUP_RW);
fdev_set_udata(streamPtr, (void *)iptr); /* Set user defined and accessible pointer */
stdout = streamPtr;
// if (strcmp(name, "stdout") == 0)
// stdout = streamPtr; /* stdout is a macro */
// else if (strcmp(name, "stdin") == 0)
// stdin = streamPtr;
// else if (strcmp(name, "stderr") == 0)
// stderr = streamPtr;
return (void *)streamPtr;
}
void mwii_init(void){
//soc_init();
time_init();
uart_init(0, 38400, uart_buffer[0], 64, uart_buffer[1], 64);
// setup printf stuff (specific to avr-libc)
fdev_set_udata(&uart_fd, uart_get_serial_interface(0));
stdout = &uart_fd;
stderr = &uart_fd;
gpio_init();
//spi_init();
avr_i2c_init(0);
pwm_init();
//adc0_init_default();
sei();
/*
// setup stdout and stderr (avr-libc specific)
fdev_setup_stream(stdout, _serial_fd_putc, _serial_fd_getc, _FDEV_SETUP_RW);
fdev_set_udata(stdout, uart_get_serial_interface(0));
fdev_setup_stream(stderr, _serial_fd_putc, _serial_fd_getc, _FDEV_SETUP_RW);
fdev_set_udata(stderr, uart_get_serial_interface(0));
*/
// first thing must enable interrupts
//kprintf("BOOT\n");
gpio_configure(GPIO_MWII_LED, GP_OUTPUT);
//gpio_set(GPIO_MWII_LED);
gpio_configure(GPIO_MWII_MOTOR0, GP_OUTPUT);
gpio_configure(GPIO_MWII_MOTOR1, GP_OUTPUT);
gpio_configure(GPIO_MWII_MOTOR2, GP_OUTPUT);
gpio_configure(GPIO_MWII_MOTOR3, GP_OUTPUT);
gpio_configure(GPIO_MWII_RX0, GP_INPUT | GP_PULLUP | GP_PCINT);
gpio_configure(GPIO_MWII_RX1, GP_INPUT | GP_PULLUP | GP_PCINT);
gpio_configure(GPIO_MWII_RX2, GP_INPUT | GP_PULLUP | GP_PCINT);
gpio_configure(GPIO_MWII_RX3, GP_INPUT | GP_PULLUP | GP_PCINT);
// calibrate escs
//mwii_calibrate_escs();
// set initial motor speeds
mwii_write_motors(MINCOMMAND, MINCOMMAND, MINCOMMAND, MINCOMMAND);
brd->gpio0 = gpio_get_parallel_interface();
brd->twi0 = avr_i2c_get_interface(0);
/*
// I2C scanner
for(int c = 0; c < 255; c++){
uint8_t buf[2];
i2c_start_read(brd->twi0, c, buf, 1);
if(i2c_stop(brd->twi0) == 1 && c & 1){
kprintf("Device %x@i2c\n", c >> 1);
}
delay_us(10000);
}
*/
gpio_set(GPIO_MWII_LED);
i2cblk_init(&brd->mpublk, brd->twi0, MPU6050_ADDR, 8, I2CBLK_IADDR8);
mpu6050_init(&brd->mpu, i2cblk_get_interface(&brd->mpublk));
//kdebug("MPU6050: %s\n", ((mpu6050_probe(&brd->mpu))?"found":"not found!"));
i2cblk_init(&brd->bmpblk, brd->twi0, BMP085_ADDR, 8, I2CBLK_IADDR8);
bmp085_init(&brd->bmp, i2cblk_get_interface(&brd->bmpblk));
//kdebug("BMP085: found\n");
i2cblk_init(&brd->hmcblk, brd->twi0, HMC5883L_ADDR, 8, I2CBLK_IADDR8);
hmc5883l_init(&brd->hmc, i2cblk_get_interface(&brd->hmcblk));
gpio_clear(GPIO_MWII_LED);
hcsr04_init(&brd->hcsr, brd->gpio0, GPIO_MWII_HCSR_TRIGGER, GPIO_MWII_HCSR_ECHO);
ASYNC_PROCESS_INIT(&brd->process, mwii_task);
ASYNC_QUEUE_WORK(&ASYNC_GLOBAL_QUEUE, &brd->process);
//mwii_calibrate_mpu6050();
// let the escs init as well
delay_us(500000L);
}
void PRNT_Device_CreateStream(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo,
FILE* const Stream)
{
*Stream = (FILE)FDEV_SETUP_STREAM(PRNT_Device_putchar, PRNT_Device_getchar, _FDEV_SETUP_RW);
fdev_set_udata(Stream, PRNTInterfaceInfo);
}
void Device_CreateStream(USB_EPInfo_Device_t* const EPInfo, FILE* const Stream)
{
*Stream = (FILE)FDEV_SETUP_STREAM(Device_putchar, Device_getchar, _FDEV_SETUP_RW);
fdev_set_udata(Stream, EPInfo);
}
uint8_t AOA_Host_StartAccessoryMode(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
{
uint8_t ErrorCode;
uint16_t AccessoryProtocol;
if ((ErrorCode = AOA_Host_GetAccessoryProtocol(&AccessoryProtocol)) != HOST_WAITERROR_Successful)
return ErrorCode;
if (AccessoryProtocol != CPU_TO_LE16(AOA_PROTOCOL_AccessoryV1))
return AOA_ERROR_LOGICAL_CMD_FAILED;
for (uint8_t PropertyIndex = 0; PropertyIndex < AOA_STRING_TOTAL_STRINGS; PropertyIndex++)
{
if ((ErrorCode = AOA_Host_SendPropertyString(AOAInterfaceInfo, PropertyIndex)) != HOST_WAITERROR_Successful)
return ErrorCode;
}
USB_ControlRequest = (USB_Request_Header_t)
{
.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_VENDOR | REQREC_DEVICE),
.bRequest = AOA_REQ_StartAccessoryMode,
.wValue = 0,
.wIndex = 0,
.wLength = 0,
};
Pipe_SelectPipe(PIPE_CONTROLPIPE);
return USB_Host_SendControlRequest(NULL);
}
static uint8_t AOA_Host_GetAccessoryProtocol(uint16_t* const Protocol)
{
USB_ControlRequest = (USB_Request_Header_t)
{
.bmRequestType = (REQDIR_DEVICETOHOST | REQTYPE_VENDOR | REQREC_DEVICE),
.bRequest = AOA_REQ_GetAccessoryProtocol,
.wValue = 0,
.wIndex = 0,
.wLength = sizeof(uint16_t),
};
Pipe_SelectPipe(PIPE_CONTROLPIPE);
return USB_Host_SendControlRequest(Protocol);
}
static uint8_t AOA_Host_SendPropertyString(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
const uint8_t StringIndex)
{
const char* String = ((char**)&AOAInterfaceInfo->Config.PropertyStrings)[StringIndex];
if (String == NULL)
String = "";
USB_ControlRequest = (USB_Request_Header_t)
{
.bmRequestType = (REQDIR_HOSTTODEVICE | REQTYPE_VENDOR | REQREC_DEVICE),
.bRequest = AOA_REQ_SendString,
.wValue = 0,
.wIndex = StringIndex,
.wLength = (strlen(String) + 1),
};
Pipe_SelectPipe(PIPE_CONTROLPIPE);
return USB_Host_SendControlRequest((char*)String);
}
uint8_t AOA_Host_SendData(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
const uint8_t* const Buffer,
const uint16_t Length)
{
if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
return PIPE_READYWAIT_DeviceDisconnected;
uint8_t ErrorCode;
Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
Pipe_Unfreeze();
ErrorCode = Pipe_Write_Stream_LE(Buffer, Length, NULL);
Pipe_Freeze();
return ErrorCode;
}
uint8_t AOA_Host_SendString(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
const char* const String)
{
if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
return PIPE_READYWAIT_DeviceDisconnected;
uint8_t ErrorCode;
Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
Pipe_Unfreeze();
ErrorCode = Pipe_Write_Stream_LE(String, strlen(String), NULL);
Pipe_Freeze();
return ErrorCode;
}
uint8_t AOA_Host_SendByte(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
const uint8_t Data)
{
if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
return PIPE_READYWAIT_DeviceDisconnected;
uint8_t ErrorCode;
Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
Pipe_Unfreeze();
if (!(Pipe_IsReadWriteAllowed()))
{
Pipe_ClearOUT();
if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
return ErrorCode;
}
Pipe_Write_8(Data);
Pipe_Freeze();
return PIPE_READYWAIT_NoError;
}
uint16_t AOA_Host_BytesReceived(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
{
if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
return 0;
Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipeNumber);
Pipe_Unfreeze();
if (Pipe_IsINReceived())
{
if (!(Pipe_BytesInPipe()))
{
Pipe_ClearIN();
Pipe_Freeze();
return 0;
}
else
{
Pipe_Freeze();
return Pipe_BytesInPipe();
}
}
else
{
Pipe_Freeze();
return 0;
}
}
int16_t AOA_Host_ReceiveByte(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
{
if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
return -1;
int16_t ReceivedByte = -1;
Pipe_SelectPipe(AOAInterfaceInfo->Config.DataINPipeNumber);
Pipe_Unfreeze();
if (Pipe_IsINReceived())
{
if (Pipe_BytesInPipe())
ReceivedByte = Pipe_Read_8();
if (!(Pipe_BytesInPipe()))
Pipe_ClearIN();
}
Pipe_Freeze();
return ReceivedByte;
}
uint8_t AOA_Host_Flush(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo)
{
if ((USB_HostState != HOST_STATE_Configured) || !(AOAInterfaceInfo->State.IsActive))
return PIPE_READYWAIT_DeviceDisconnected;
uint8_t ErrorCode;
Pipe_SelectPipe(AOAInterfaceInfo->Config.DataOUTPipeNumber);
Pipe_Unfreeze();
if (!(Pipe_BytesInPipe()))
return PIPE_READYWAIT_NoError;
bool BankFull = !(Pipe_IsReadWriteAllowed());
Pipe_ClearOUT();
if (BankFull)
{
if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
return ErrorCode;
Pipe_ClearOUT();
}
Pipe_Freeze();
return PIPE_READYWAIT_NoError;
}
#if defined(FDEV_SETUP_STREAM)
void AOA_Host_CreateStream(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
FILE* const Stream)
{
*Stream = (FILE)FDEV_SETUP_STREAM(AOA_Host_putchar, AOA_Host_getchar, _FDEV_SETUP_RW);
fdev_set_udata(Stream, AOAInterfaceInfo);
}
void AOA_Host_CreateBlockingStream(USB_ClassInfo_AOA_Host_t* const AOAInterfaceInfo,
FILE* const Stream)
{
*Stream = (FILE)FDEV_SETUP_STREAM(AOA_Host_putchar, AOA_Host_getchar_Blocking, _FDEV_SETUP_RW);
fdev_set_udata(Stream, AOAInterfaceInfo);
}
FILE *uart_fopen(uart_t *u)
{
FILE *fp = fdevopen(uart_dev_send, uart_dev_recv);
fdev_set_udata(fp, u);
return fp;
}