void usbToUartService()
{
uint8 signals;
// Data
while(usbComRxAvailable() && uart1TxAvailable())
{
uart1TxSendByte(usbComRxReceiveByte());
}
while(uart1RxAvailable() && usbComTxAvailable())
{
usbComTxSendByte(uart1RxReceiveByte());
}
// Control lines controlled by computer.
P1_0 = !(usbComRxControlSignals() & ACM_CONTROL_LINE_DTR);
P1_1 = !(usbComRxControlSignals() & ACM_CONTROL_LINE_RTS);
P1DIR |= (1<<0) | (1<<1);
// Control lines controlled by device.
signals = 0;
if (!P1_2){ signals |= ACM_SERIAL_STATE_TX_CARRIER; } // TX Carrier = DSR
if (!P1_3){ signals |= ACM_SERIAL_STATE_RX_CARRIER; } // RX Carrier = CD
usbComTxControlSignals(signals);
}
/** Checks for new bytes available on the USB virtual COM port
* and processes all that are available. */
void processBytesFromUsb()
{
uint8 bytesLeft = usbComRxAvailable();
while(bytesLeft && usbComTxAvailable() >= sizeof(response))
{
processByte(usbComRxReceiveByte());
bytesLeft--;
}
}
void receiveCommands()
{
if (usbComRxAvailable() && usbComTxAvailable() >= 64)
{
uint8 XDATA response[64];
uint8 responseLength;
uint8 byte, rand;
byte = usbComRxReceiveByte();
// By default, echo back the byte that was send.
response[0] = byte;
responseLength = 1;
// By default, stop blinking the yellow LED because it will
// affect the sequence of random numbers reported to the COM port.
blinkYellow = 0;
switch(byte)
{
case 'Y': blinkYellow = 1; break;
case 's': randomSeedFromSerialNumber(); break;
case 'a': randomSeedFromAdc(); break;
case '0': randomSeed(0,0); break;
case '1': randomSeed(0xFF, 0xFF); break;
case '8': randomSeed(0x80, 0x03); break;
case 'r':
rand = randomNumber();
// Wait for the NEXT random number to finish so we can read RNDH and RNDL.
while(ADCCON1 & 0x0C);
response[responseLength++] = ',';
response[responseLength++] = nibbleToAscii(rand >> 4);
response[responseLength++] = nibbleToAscii(rand);
response[responseLength++] = ',';
response[responseLength++] = (rand & 0x80) ? '1' : '0';
response[responseLength++] = (rand & 0x40) ? '1' : '0';
response[responseLength++] = (rand & 0x20) ? '1' : '0';
response[responseLength++] = (rand & 0x10) ? '1' : '0';
response[responseLength++] = (rand & 0x08) ? '1' : '0';
response[responseLength++] = (rand & 0x04) ? '1' : '0';
response[responseLength++] = (rand & 0x02) ? '1' : '0';
response[responseLength++] = (rand & 0x01) ? '1' : '0';
response[responseLength++] = ',';
response[responseLength++] = nibbleToAscii(RNDH >> 4);
response[responseLength++] = nibbleToAscii(RNDH);
response[responseLength++] = nibbleToAscii(RNDL >> 4);
response[responseLength++] = nibbleToAscii(RNDL);
response[responseLength++] = '\r';
response[responseLength++] = '\n';
break;
default: response[0] = '?'; break;
}
usbComTxSend(response, responseLength);
}
void handleOneWire(void)
{
int i;
int newtemp = 0;
int air_temp_c = 0;
unsigned int decimals;
if (getMs() > ds1820_time + 1000) {
air_temp_c = read_DS1820();
newtemp++;
start_DS1820();
ds1820_time = getMs();
}
if ((newtemp || respondstr) && usbComTxAvailable() >= 64)
{
const char *cp;
uint8 XDATA response[64];
uint8 responseLength = 0;
decimals = (air_temp_c & 0xf) * 100;
responseLength = sprintf(response, "%d.%02d", air_temp_c / 16, decimals / 16);
response[responseLength++] = ',';
for (i = 0; i < 8; i++) {
response[responseLength++] = nibbleToAscii(DS1820_addr[i] >> 4);
response[responseLength++] = nibbleToAscii(DS1820_addr[i]);
}
response[responseLength++] = ',';
i = sizeof(response) - responseLength - 2;
if (respondstr) {
for (cp = respondstr; *respondstr && i--; respondstr++) {
response[responseLength++] = *cp;
}
}
respondstr = NULL;
response[responseLength++] = '\r';
response[responseLength++] = '\n';
usbComTxSend(response, responseLength);
}
}
void usbToUartService()
{
uint8 signals;
// Data
while(usbComRxAvailable() && !spi0MasterBusy())
{
spi0MasterSendByte(usbComRxReceiveByte());
}
while(!spi0MasterBusy() && usbComTxAvailable())
{
usbComTxSendByte(spi0MasterReceiveByte());
}
ioTxSignals(usbComRxControlSignals());
// Need to switch bits 0 and 1 so that DTR pairs up with DSR.
signals = ioRxSignals();
usbComTxControlSignals( ((signals & 1) ? 2 : 0) | ((signals & 2) ? 1 : 0));
// TODO: report framing, parity, and overrun errors to the USB host here
}
void usbToRadioService()
{
uint8 signals;
// Data
while(usbComRxAvailable() && radioComTxAvailable())
{
radioComTxSendByte(usbComRxReceiveByte());
}
while(radioComRxAvailable() && usbComTxAvailable())
{
usbComTxSendByte(radioComRxReceiveByte());
}
// Control Signals
radioComTxControlSignals(usbComRxControlSignals() & 3);
// Need to switch bits 0 and 1 so that DTR pairs up with DSR.
signals = radioComRxControlSignals();
usbComTxControlSignals( ((signals & 1) ? 2 : 0) | ((signals & 2) ? 1 : 0));
}
void sendReportIfNeeded()
{
static uint32 lastReport;
uint8 i, bytesToSend;
uint16 result[6];
uint16 vddMillivolts;
// Create reports.
if (getMs() - lastReport >= param_report_period_ms && reportLength == 0)
{
lastReport = getMs();
reportBytesSent = 0;
vddMillivolts = adcReadVddMillivolts();
adcSetMillivoltCalibration(vddMillivolts);
for(i = 0; i < 6; i++)
{
result[i] = adcRead(i);
}
if (param_bar_graph)
{
printf("\x1B[0;0H"); // VT100 command for "go to 0,0"
printBar("P0_0", result[0]);
printBar("P0_1", result[1]);
printBar("P0_2", result[2]);
printBar("P0_3", result[3]);
printBar("P0_4", result[4]);
printBar("P0_5", result[5]);
printf("VDD %4d mV", vddMillivolts);
}
else
{
printf("A, %4d, %4d, %4d, %4d, %4d, %4d,\r\n",
adcConvertToMillivolts(result[0]),
adcConvertToMillivolts(result[1]),
adcConvertToMillivolts(result[2]),
adcConvertToMillivolts(result[3]),
adcConvertToMillivolts(result[4]),
adcConvertToMillivolts(result[5])
);
}
}
// Send the report to USB in chunks.
if (reportLength > 0)
{
bytesToSend = usbComTxAvailable();
if (bytesToSend > reportLength - reportBytesSent)
{
// Send the last part of the report.
usbComTxSend(report+reportBytesSent, reportLength - reportBytesSent);
reportLength = 0;
}
else
{
usbComTxSend(report+reportBytesSent, bytesToSend);
reportBytesSent += bytesToSend;
}
}
}
