int main(void) {
fiprintf(stderr, "Power Up!\n\r");
while (1) {
GPIO_SET(IO_LED);
GPIO_SET(IO_ASSIST_AIR);
GPIO_CLEAR(IO_EXHAUST);
GPIO_CLEAR(IO_LASER_FIRE);
delay(500);
GPIO_CLEAR(IO_LED);
GPIO_CLEAR(IO_ASSIST_AIR);
GPIO_SET(IO_EXHAUST);
GPIO_SET(IO_LASER_FIRE);
delay(500);
fiprintf(stderr, "USB connected: %d\n\r", usbConnected());
if (usbConnected()) {
usbSendFlush(TESTHEST, sizeof(TESTHEST));
}
fiprintf(stderr, "Airflow: %d (%d %%)\n\r", READ_ADC(IO_AIRFLOW), airflow());
fprintf(stderr, "T out: %d (%f Ohm, %f degC)\n\r",
READ_ADC(IO_TEMP_OUT),
readNTCres(IO_CHAN(IO_TEMP_OUT)),
readNTCcelcius(IO_CHAN(IO_TEMP_OUT))
);
fprintf(stderr, "T in: %f degC\n\r", readNTCcelcius(IO_CHAN(IO_TEMP_IN)));
fprintf(stderr, "T inter: %f degC\n\r", readNTCcelcius(IO_CHAN(IO_TEMP_INTERNAL)));
fiprintf(stderr, "Supply: %d mv\n\r", supplyVoltage());
unsigned int err0 = errorUART(IO_DEBUG_RX);
if (err0) {
fiprintf(stderr, "Debug UART Error: %x\n\r", err0);
}
err0 = errorUART(IO_WATCHDOG_RX);
if (err0) {
fiprintf(stderr, "Watchdog UART Error: %x\n\r", err0);
}
err0 = errorUART(IO_CHILLER_RX);
if (err0) {
fiprintf(stderr, "Chiller UART Error: %x\n\r", err0);
}
}
}
/* Setup UART handle and parameters */
static void setupUART()
{
uint32_t frg_mult;
/* 115.2KBPS, 8N1, ASYNC mode, no errors, clock filled in later */
UART_CONFIG_T cfg = {
0, /* U_PCLK frequency in Hz */
115200, /* Baud Rate in Hz */
1, /* 8N1 */
0, /* Asynchronous Mode */
NO_ERR_EN /* Enable No Errors */
};
/* Perform a sanity check on the storage allocation */
if (LPC_UARTD_API->uart_get_mem_size() > sizeof(uartHandleMEM)) {
/* Example only: this should never happen and probably isn't needed for
most UART code. */
errorUART();
}
/* Setup the UART handle */
uartHandle = LPC_UARTD_API->uart_setup((uint32_t) LPC_USART0, (uint8_t *) &uartHandleMEM);
if (uartHandle == NULL) {
errorUART();
}
/* Need to tell UART ROM API function the current UART peripheral clock
speed */
cfg.sys_clk_in_hz = Chip_Clock_GetAsyncSysconClockRate();
/* Initialize the UART with the configuration parameters */
frg_mult = LPC_UARTD_API->uart_init(uartHandle, &cfg);
if (frg_mult) {
Chip_Clock_EnableAsyncPeriphClock(ASYNC_SYSCTL_CLOCK_FRG);
Chip_SYSCTL_SetUSARTFRGCtrl(frg_mult, 0xFF);
}
}
/* Send a string on the UART terminated by a NULL character using
polling mode. */
static void putLineUART(const char *send_data)
{
UART_PARAM_T param;
param.buffer = (uint8_t *) send_data;
param.size = strlen(send_data);
/* Polling mode, do not append CR/LF to sent data */
param.transfer_mode = TX_MODE_SZERO;
param.driver_mode = DRIVER_MODE_POLLING;
/* Transmit the data */
if (LPC_UARTD_API->uart_put_line(uartHandle, ¶m)) {
errorUART();
}
}
/* Receive a string on the UART terminated by a LF character using
polling mode. */
static void getLineUART(char *receive_buffer, uint32_t length)
{
UART_PARAM_T param;
param.buffer = (uint8_t *) receive_buffer;
param.size = length;
/* Receive data up to the CR/LF character in polling mode. Will
truncate at length if too long. */
param.transfer_mode = RX_MODE_CRLF_RECVD;
param.driver_mode = DRIVER_MODE_POLLING;
/* Receive the data */
if (LPC_UARTD_API->uart_get_line(uartHandle, ¶m)) {
errorUART();
}
}
