uint16_t hardware_analogRead(uint8_t ch)
{
uint32_t buf = 0;
// Initialize the ADC driver before first use
ADC_Init(ADC_FREE_RUNNING | ADC_PRESCALE_32);
// Must setup the ADC channel to read beforehand
if(ch < 15)
ADC_SetupChannel(ch);
if(ch > 7)
ch = (1 << 8 | ((ch - 8) << MUX0));
else
ch = ch << MUX0;
// Perform a single conversion of the ADC channel 1
// buf = ADC_GetChannelReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | ch);
// Start reading ADC channel 1 in free running (continuous conversion) mode
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | ch);
for(uint8_t i = 0; i < ADC_READINGS; i++)
{
while (!(ADC_IsReadingComplete()));
buf += ADC_GetResult();
}
// Leave ADC Disabled to save power
ADC_Disable();
return (uint16_t)(buf / ADC_READINGS);
}
/** ISR to handle the reloading of the PWM timer with the next sample. */
ISR(TIMER0_COMPA_vect, ISR_BLOCK)
{
uint8_t PrevPipe = Pipe_GetCurrentPipe();
/* Check that the USB bus is ready for the next sample to write */
if (Audio_Host_IsReadyForNextSample(&Speaker_Audio_Interface))
{
int16_t AudioSample;
#if defined(USE_TEST_TONE)
static uint8_t SquareWaveSampleCount;
static int16_t CurrentWaveValue;
/* In test tone mode, generate a square wave at 1/256 of the sample rate */
if (SquareWaveSampleCount++ == 0xFF)
CurrentWaveValue ^= 0x8000;
/* Only generate audio if the board button is being pressed */
AudioSample = (Buttons_GetStatus() & BUTTONS_BUTTON1) ? CurrentWaveValue : 0;
#else
/* Audio sample is ADC value scaled to fit the entire range */
AudioSample = ((SAMPLE_MAX_RANGE / ADC_MAX_RANGE) * ADC_GetResult());
#if defined(MICROPHONE_BIASED_TO_HALF_RAIL)
/* Microphone is biased to half rail voltage, subtract the bias from the sample value */
AudioSample -= (SAMPLE_MAX_RANGE / 2);
#endif
#endif
Audio_Host_WriteSample16(&Speaker_Audio_Interface, AudioSample);
Audio_Host_WriteSample16(&Speaker_Audio_Interface, AudioSample);
}
Pipe_SelectPipe(PrevPipe);
}
/** Updates any parameter values that are sourced from hardware rather than explicitly set by the host, such as
* VTARGET levels from the ADC on supported AVR models.
*/
void V2Params_UpdateParamValues(void)
{
#if defined(ADC)
/* Update VTARGET parameter with the latest ADC conversion of VTARGET on supported AVR models */
V2Params_GetParamFromTable(PARAM_VTARGET)->ParamValue = ((5 * 10 * ADC_GetResult()) / 1024);
#endif
}
/** ISR to handle the reloading of the endpoint with the next sample. */
ISR(TIMER0_COMPA_vect, ISR_BLOCK)
{
uint8_t PrevPipe = Pipe_GetCurrentPipe();
Pipe_SelectPipe(AUDIO_DATA_OUT_PIPE);
Pipe_Unfreeze();
/* Check if the current pipe can be written to (device ready for more data) */
if (Pipe_IsOUTReady())
{
int16_t AudioSample;
#if defined(USE_TEST_TONE)
static uint8_t SquareWaveSampleCount;
static int16_t CurrentWaveValue;
/* In test tone mode, generate a square wave at 1/256 of the sample rate */
if (SquareWaveSampleCount++ == 0xFF)
CurrentWaveValue ^= 0x8000;
/* Only generate audio if the board button is being pressed */
AudioSample = (Buttons_GetStatus() & BUTTONS_BUTTON1) ? CurrentWaveValue : 0;
#else
/* Audio sample is ADC value scaled to fit the entire range */
AudioSample = ((SAMPLE_MAX_RANGE / ADC_MAX_RANGE) * ADC_GetResult());
#if defined(MICROPHONE_BIASED_TO_HALF_RAIL)
/* Microphone is biased to half rail voltage, subtract the bias from the sample value */
AudioSample -= (SAMPLE_MAX_RANGE / 2);
#endif
#endif
Pipe_Write_16_LE(AudioSample);
Pipe_Write_16_LE(AudioSample);
if (!(Pipe_IsReadWriteAllowed()))
Pipe_ClearOUT();
}
Pipe_Freeze();
Pipe_SelectPipe(PrevPipe);
}
/** Task to manage the Audio interface, reading in ADC samples from the microphone, and them to the host. */
void USB_Audio_Task(void)
{
/* Device must be connected and configured for the task to run */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
/* Check to see if the streaming interface is selected, if not the host is not receiving audio */
if (!(StreamingAudioInterfaceSelected))
return;
/* Select the audio stream endpoint */
Endpoint_SelectEndpoint(AUDIO_STREAM_EPNUM);
/* Check if the current endpoint can be written to and that the next sample should be stored */
if (Endpoint_IsINReady() && (TIFR0 & (1 << OCF0A)))
{
/* Clear the sample reload timer */
TIFR0 |= (1 << OCF0A);
/* Audio sample is ADC value scaled to fit the entire range */
int16_t AudioSample = ((SAMPLE_MAX_RANGE / ADC_MAX_RANGE) * ADC_GetResult());
#if defined(MICROPHONE_BIASED_TO_HALF_RAIL)
/* Microphone is biased to half rail voltage, subtract the bias from the sample value */
AudioSample -= (SAMPLE_MAX_RANGE / 2);
#endif
/* Write the sample to the buffer */
Endpoint_Write_Word_LE(AudioSample);
/* Check to see if the bank is now full */
if (!(Endpoint_IsReadWriteAllowed()))
{
/* Send the full packet to the host */
Endpoint_ClearIN();
}
}
}
void SensorFastLoopControl(bool bOff)
{
if (bOff)
{
if (!bMeasureFinished)
{
bSensorDisableLights = true;
bMeasure = true;
}
if (bMeasure)
{
LocalCnt++;
if (LocalCnt > SENSOR_SKIP_NUMBER)
{
LocalSum += ADC_GetResult(ADC_LIGHT_SENS_CHANNEL);
//LocalCnt++;
if (LocalCnt >= (SENSOR_MEASURE_NUMBER+SENSOR_SKIP_NUMBER))
{
// MeasureFinished
bSensorDataReady = true;
bMeasureFinished = true;
bMeasure = false;
bSensorDisableLights = false;
}
}
}
}
else
{
if (bMeasureFinished)
{
bMeasureFinished = false;
}
}
}
/** Updates any parameter values that are sourced from hardware rather than explicitly set by the host, such as
* VTARGET levels from the ADC on supported AVR models.
*/
void V2Params_UpdateParamValues(void)
{
#if (defined(ADC) && !defined(NO_VTARGET_DETECT))
/* Update VTARGET parameter with the latest ADC conversion of VTARGET on supported AVR models */
V2Params_GetParamFromTable(PARAM_VTARGET)->ParamValue = (((uint16_t)(VTARGET_REF_VOLTS * 10 * VTARGET_SCALE_FACTOR) * ADC_GetResult()) / 1024);
#endif
}
void SensorPreInitMeasure(void)
{
int i;
volatile int j;
uint32 StartDeltaT; // (CurTime - StartTime) sec
uint32 LastDeltaT; // (CurTime - LastTime) sec
CurTime = Status.CurDateTime;
LocalSum = 0;
LastDeltaT = CalcTimeDelta(Status.CurDateTime.hour, Status.CurDateTime.min, Status.CurDateTime.sec,
SensorInfo.LastHour, SensorInfo.LastMin, SensorInfo.LastSec
);
ForcedMeasureCount = LastDeltaT;
if (LastDeltaT > NO_MEASURE_TIME)
{
StartDeltaT = CalcTimeDelta(Status.CurDateTime.hour, Status.CurDateTime.min, Status.CurDateTime.sec,
SensorInfo.StartHour, SensorInfo.StartMin, SensorInfo.StartSec
);
LearnCount = StartDeltaT;
if (ForcedMeasureCount > FORCED_LEARN_TIME)
{
SensorInfo.TotalSum = 0;
SensorInfo.TotalCnt = 0;
LocalSum = 0;
LocalCnt = 0;
LocalValue = 0;
SensorInfo.SensorInvalid |= SENSOR_LEARN_FLAG;
LearnCount = 0;
}
for (i=0; i<SENSOR_MEASURE_NUMBER; i++)
{
LocalSum += ADC_GetResult(ADC_LIGHT_SENS_CHANNEL);
LocalCnt++;
// Delay
for (j=0;j<300;j++);
}
LocalValue = LocalSum/LocalCnt;
LocalSum = 0;
LocalCnt = 0;
// LastTime = CurTime;
SensorInfo.LastHour = Status.CurDateTime.hour;
SensorInfo.LastMin = Status.CurDateTime.min;
SensorInfo.LastSec = Status.CurDateTime.sec;
ForcedMeasureCount = 0;
if ( (LearnCount > ((uint32)Config2.SensorFilterTime*60)) && SensorInfo.TotalCnt )
{
SensorInfo.SensorValue = SensorInfo.TotalSum/SensorInfo.TotalCnt;
SensorInfo.TotalSum = 0;
SensorInfo.TotalCnt = 0;
SensorInfo.SensorInvalid &= ~SENSOR_LEARN_FLAG;
}
if (!SensorInfo.TotalCnt)
{
// StartTime = CurTime;
SensorInfo.StartHour = Status.CurDateTime.hour;
SensorInfo.StartMin = Status.CurDateTime.min;
SensorInfo.StartSec = Status.CurDateTime.sec;
LearnCount = 0;
}
SensorInfo.TotalSum += LocalValue;
SensorInfo.TotalCnt++;
}
}
void ProcessLightSensor(void)
{
SensorInfo.SensorValue += ADC_GetResult(ADC_LIGHT_SENS_CHANNEL);
SensorInfo.SensorValue >>= 1;
}
void ButtonStates(void) {
uint16_t port, result;
char buffer[64];
PORTD = 0b11111111;
/*for (int i=0; i<4; i++) {
if (i > 1) {
PORTC = (i%1 == 0) ? 0b01000000 : 0b10000000;
} else {
PORTB = (i%1 == 0) ? 0b01000000 : 0b10000000;
}
*/
// TODO: dry this up
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL0);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "4,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL1);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "0,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL4);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "1,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL5);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "2,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL6);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "3,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL12);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "7,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL13);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "6,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_LEFT_ADJUSTED | ADC_CHANNEL7);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, "5,%d\n", ADC_GetResult());
fputs(buffer, &USBSerialStream);
/*
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | ADC_CHANNEL5);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, " %d", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | ADC_CHANNEL6);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, " %d", ADC_GetResult());
fputs(buffer, &USBSerialStream);
ADC_StartReading(ADC_REFERENCE_AVCC | ADC_RIGHT_ADJUSTED | ADC_CHANNEL7);
while(!(ADC_IsReadingComplete())) {}
sprintf(buffer, " %d", ADC_GetResult());
fputs(buffer, &USBSerialStream);
PORTB = 0;
PORTC = 0;
//}
*/
}
bool TestRG_ShowLowVolt(bool bInit)
{
static int Test_ShowLV_State;
static uint16 Voltage;
if (bInit)
{
TestStatePrev = TestState;
secCounter = 0;
TestCounter = 0;
Test_sec = 0;
Test_DigG = -1;
Test_DigR = -1;
DigMask = 0;
RedManVar = 0;
GreenManVar = 0;
GManPhase = 0;
Test_ShowLV_State = 0;
}
secCounter++;
switch (Test_ShowLV_State)
{
case 0:
{
if (secCounter>=TEST_MEASURE_LV_TIME)
{
Voltage = ADC_GetResult(ADC_POWER_FB_CHANNEL);
Test_DigG = (VOLTAGE_SCALE * (uint32)Voltage) >> 16;
DigMask = CalcNumberMask(Test_DigG, GREEN_MAX_COUNT);
RedManVar = 0;
GreenManVar = GMAN0_MASK|GMAN1_MASK;
GManPhase = 0;
secCounter = 0;
Test_ShowLV_State = 1;
}
break;
};
case 1:
{
if (secCounter>=TEST_SHOW_LV_TIME)
{
//DigMask = 0;
//RedManVar = RMAN_MASK;
//GreenManVar = 0;
//GManPhase = 0;
secCounter = 0;
//Test_ShowLV_State = 2;
return true;
}
break;
};
//case 2:
//{
// if (secCounter>=TEST_RED_PAUSE_TIME)
// {
// secCounter = 0;
// return true;
// }
//
// break;
//};
default:
{
Test_ShowLV_State = 0;
break;
}
}
