int HAL_Feature_Set(HAL_Feature feature, bool enabled)
{
switch (feature)
{
case FEATURE_RETAINED_MEMORY:
{
FunctionalState state = enabled ? ENABLE : DISABLE;
// Switch on backup SRAM clock
// Switch on backup power regulator, so that it survives the deep sleep mode,
// software and hardware reset. Power must be supplied to VIN or VBAT to retain SRAM values.
PWR_BackupRegulatorCmd(state);
// Wait until backup power regulator is ready, should be fairly instantaneous... but timeout in 10ms.
if (state == ENABLE) {
system_tick_t start = HAL_Timer_Get_Milli_Seconds();
while (PWR_GetFlagStatus(PWR_FLAG_BRR) == RESET) {
if (HAL_Timer_Get_Milli_Seconds() - start > 10UL) {
return -2;
}
};
}
return 0;
}
}
return -1;
}
// this is called on multiple threads - ideally need a mutex
void HAL_Notify_Button_State(uint8_t button, uint8_t pressed)
{
if (button==0)
{
if (pressed)
{
wasListeningOnButtonPress = network.listening();
buttonPushed = HAL_Timer_Get_Milli_Seconds();
if (!wasListeningOnButtonPress) // start of button press
{
system_notify_event(button_status, 0);
}
}
else
{
int release_time = HAL_Timer_Get_Milli_Seconds();
uint16_t duration = release_time-buttonPushed;
if (!network.listening()) {
system_notify_event(button_status, duration);
handle_button_click(duration, release_time);
}
buttonPushed = 0;
if (duration>3000 && duration<8000 && wasListeningOnButtonPress && network.listening())
network.listen(true);
}
}
}
int wlan_connected_rssi()
{
int _returnValue = 0;
system_tick_t _functionStart = HAL_Timer_Get_Milli_Seconds();
while ((HAL_Timer_Get_Milli_Seconds() - _functionStart) < 1000) {
tNetappIpconfigRetArgs config;
netapp_ipconfig((void*)&config);
int l;
for (l=0; l<16; l++)
{
char wlan_scan_results_table[50];
if(wlan_ioctl_get_scan_results(0, (unsigned char*)wlan_scan_results_table) != 0) {
_returnValue = 1;
break;
}
if (wlan_scan_results_table[0] == 0)
break;
if (!strcmp(wlan_scan_results_table+12, config.uaSSID)) {
_returnValue = ((wlan_scan_results_table[8] >> 1) - 127);
break;
}
}
if (_returnValue != 0) {
break;
}
}
void log_message_v(int level, const char *category, LogAttributes *attr, void *reserved, const char *fmt, va_list args) {
const log_message_callback_type msg_callback = log_msg_callback;
if (!msg_callback && (!log_compat_callback || level < log_compat_level)) {
return;
}
// Set default attributes
if (!attr->has_time) {
LOG_ATTR_SET(*attr, time, HAL_Timer_Get_Milli_Seconds());
}
char buf[LOG_MAX_STRING_LENGTH];
if (msg_callback) {
const int n = vsnprintf(buf, sizeof(buf), fmt, args);
if (n > (int)sizeof(buf) - 1) {
buf[sizeof(buf) - 2] = '~';
}
msg_callback(buf, level, category, attr, 0);
} else {
// Using compatibility callback
const char* const levelName = log_level_name(level, 0);
int n = 0;
if (attr->has_file && attr->has_line && attr->has_function) {
n = snprintf(buf, sizeof(buf), "%010u %s:%d, %s: %s", (unsigned)attr->time, attr->file, attr->line,
attr->function, levelName);
} else {
n = snprintf(buf, sizeof(buf), "%010u %s", (unsigned)attr->time, levelName);
}
if (n > (int)sizeof(buf) - 1) {
buf[sizeof(buf) - 2] = '~';
}
log_compat_callback(buf);
log_compat_callback(": ");
n = vsnprintf(buf, sizeof(buf), fmt, args);
if (n > (int)sizeof(buf) - 1) {
buf[sizeof(buf) - 2] = '~';
}
log_compat_callback(buf);
log_compat_callback("\r\n");
}
}
void ActiveObjectBase::run()
{
/* XXX: We shouldn't constantly hold a mutex. This breaks priority inhertiance mechanisms in FreeRTOS. */
/* It's not even used anywhere */
// std::lock_guard<std::mutex> lck (_start);
started = true;
uint32_t last_background_run = 0;
for (;;)
{
uint32_t now;
if (!process())
{
configuration.background_task();
}
else if ((now=HAL_Timer_Get_Milli_Seconds())-last_background_run > configuration.take_wait)
{
last_background_run = now;
configuration.background_task();
}
}
}
uint8_t HAL_I2C_End_Transmission(HAL_I2C_Interface i2c, uint8_t stop, void* reserved)
{
uint32_t _millis;
_millis = HAL_Timer_Get_Milli_Seconds();
/* While the I2C Bus is busy */
while(I2C_GetFlagStatus(i2cMap[i2c]->I2C_Peripheral, I2C_FLAG_BUSY))
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
return 1;
}
}
/* Send START condition */
I2C_GenerateSTART(i2cMap[i2c]->I2C_Peripheral, ENABLE);
_millis = HAL_Timer_Get_Milli_Seconds();
while(!I2C_CheckEvent(i2cMap[i2c]->I2C_Peripheral, I2C_EVENT_MASTER_MODE_SELECT))
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
return 2;
}
}
/* Ensure ackFailure flag is cleared */
i2cMap[i2c]->ackFailure = false;
/* Send Slave address for write */
I2C_Send7bitAddress(i2cMap[i2c]->I2C_Peripheral, i2cMap[i2c]->txAddress, I2C_Direction_Transmitter);
_millis = HAL_Timer_Get_Milli_Seconds();
while(!I2C_CheckEvent(i2cMap[i2c]->I2C_Peripheral, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
{
/* STOP/RESET immediately if ACK failure detected */
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis) || i2cMap[i2c]->ackFailure)
{
/* Send STOP Condition */
I2C_GenerateSTOP(i2cMap[i2c]->I2C_Peripheral, ENABLE);
/* Wait to make sure that STOP control bit has been cleared */
_millis = HAL_Timer_Get_Milli_Seconds();
while(i2cMap[i2c]->I2C_Peripheral->CR1 & I2C_CR1_STOP)
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
break;
}
}
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
/* Ensure ackFailure flag is cleared */
i2cMap[i2c]->ackFailure = false;
return 3;
}
}
uint8_t *pBuffer = i2cMap[i2c]->txBuffer;
uint8_t NumByteToWrite = i2cMap[i2c]->txBufferLength;
/* While there is data to be written */
while(NumByteToWrite--)
{
/* Send the current byte to slave */
I2C_SendData(i2cMap[i2c]->I2C_Peripheral, *pBuffer);
/* Point to the next byte to be written */
pBuffer++;
_millis = HAL_Timer_Get_Milli_Seconds();
while(!I2C_CheckEvent(i2cMap[i2c]->I2C_Peripheral, I2C_EVENT_MASTER_BYTE_TRANSMITTING))
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
return 4;
}
}
_millis = HAL_Timer_Get_Milli_Seconds();
while(I2C_GetFlagStatus(i2cMap[i2c]->I2C_Peripheral, I2C_FLAG_BTF) == RESET)
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
return 5;
}
}
}
/* Send STOP Condition */
if(stop == true)
{
/* Send STOP condition */
I2C_GenerateSTOP(i2cMap[i2c]->I2C_Peripheral, ENABLE);
}
// reset tx buffer iterator vars
i2cMap[i2c]->txBufferIndex = 0;
i2cMap[i2c]->txBufferLength = 0;
// indicate that we are done transmitting
i2cMap[i2c]->transmitting = 0;
return 0;
}
uint32_t HAL_I2C_Request_Data(HAL_I2C_Interface i2c, uint8_t address, uint8_t quantity, uint8_t stop, void* reserved)
{
uint32_t _millis;
uint8_t bytesRead = 0;
// clamp to buffer length
if(quantity > BUFFER_LENGTH)
{
quantity = BUFFER_LENGTH;
}
/* Send START condition */
I2C_GenerateSTART(i2cMap[i2c]->I2C_Peripheral, ENABLE);
_millis = HAL_Timer_Get_Milli_Seconds();
while(!I2C_CheckEvent(i2cMap[i2c]->I2C_Peripheral, I2C_EVENT_MASTER_MODE_SELECT))
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
return 0;
}
}
/* Initialized variables here to minimize delays
* between sending of slave addr and read loop
*/
uint8_t *pBuffer = i2cMap[i2c]->rxBuffer;
uint8_t numByteToRead = quantity;
/* Ensure ackFailure flag is cleared */
i2cMap[i2c]->ackFailure = false;
/* Set ACK/NACK prior to I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED check
* to minimize delays between sending of slave addr and read loop.
* I2C_CheckEvent() will clear ADDR bit and allow SCL clocks to run, so we don't
* have much time to check/set this correctly while I2C is in operation.
*/
if (quantity == 1)
/* Disable Acknowledgement */
I2C_AcknowledgeConfig(i2cMap[i2c]->I2C_Peripheral, DISABLE);
else
I2C_AcknowledgeConfig(i2cMap[i2c]->I2C_Peripheral, ENABLE);
/* Send Slave address for read */
I2C_Send7bitAddress(i2cMap[i2c]->I2C_Peripheral, address << 1, I2C_Direction_Receiver);
_millis = HAL_Timer_Get_Milli_Seconds();
while(!I2C_CheckEvent(i2cMap[i2c]->I2C_Peripheral, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
{
/* STOP/RESET immediately if ACK failure detected */
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis) || i2cMap[i2c]->ackFailure)
{
/* Send STOP Condition */
I2C_GenerateSTOP(i2cMap[i2c]->I2C_Peripheral, ENABLE);
/* Wait to make sure that STOP control bit has been cleared */
_millis = HAL_Timer_Get_Milli_Seconds();
while(i2cMap[i2c]->I2C_Peripheral->CR1 & I2C_CR1_STOP)
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
break;
}
}
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
/* Ensure ackFailure flag is cleared */
i2cMap[i2c]->ackFailure = false;
return 0;
}
}
/* DATA on SDA --> Shift Register (SR) [8 clocks by SCL] --> Data Register (DR) --> ACK/NACK (9th clock)
*
* SINGLE BYTE READ
* - SCL will run immediately after ADDR bit is cleared by reading SR2 (any I2C_CheckEvent)
* - DR will be empty
* - 1st byte from slave will be transferred to DR after 8th SCL clock
* - ACK/NACK will be sent immediately (SCL will run 9th clock)
*
* 2 BYTES LEFT TO READ
* - DR is not yet empty (2nd last byte is in DR; it was ACKed on its xfer to DR)
* - Last byte is being assembled in SR
* - SCL will be stretched after 8th clock (SR full) until DR is empty
* - Reading DR for 2nd last byte will then move last byte to DR and send ACK/NACK
*
* While there is data to be read, perform blocking read into buffer
*/
while(numByteToRead)
{
/* Wait for DR to be full. As soon as DR is full, the byte that was xfer'd from SR
* to DR will be ACK/NACK'd. So it is important to enable/disable ACK bit ahead of this event
*/
_millis = HAL_Timer_Get_Milli_Seconds();
while(I2C_GetFlagStatus(i2cMap[i2c]->I2C_Peripheral, I2C_FLAG_RXNE) == RESET)
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
return 0;
}
}
switch (numByteToRead) {
case 2:
/* Disable Acknowledgement on last byte which is being assembled in SR,
* 2nd last byte is in the DR and as soon as we read the 2nd last byte
* below, last byte will be moved into DR and ACK/NACK will be sent.
*/
I2C_AcknowledgeConfig(i2cMap[i2c]->I2C_Peripheral, DISABLE);
break;
case 1:
/* Send STOP Condition */
if (stop == true)
I2C_GenerateSTOP(i2cMap[i2c]->I2C_Peripheral, ENABLE);
break;
default:
break;
}
/* Read the byte out of the Data Register that was received from the Slave.
* This will enable the transfer of the next byte (if any) from the Shift Register to
* the Data Register and also will send ACK/NACK for that byte
*/
*pBuffer = I2C_ReceiveData(i2cMap[i2c]->I2C_Peripheral);
bytesRead++;
/* Point to the next location where the byte read will be saved */
pBuffer++;
/* Decrement the read bytes counter */
numByteToRead--;
/* Wait to make sure that STOP control bit has been cleared */
_millis = HAL_Timer_Get_Milli_Seconds();
while(i2cMap[i2c]->I2C_Peripheral->CR1 & I2C_CR1_STOP)
{
if(EVENT_TIMEOUT < (HAL_Timer_Get_Milli_Seconds() - _millis))
{
/* SW Reset the I2C Peripheral */
HAL_I2C_SoftwareReset(i2c);
return 0;
}
}
}
// set rx buffer iterator vars
i2cMap[i2c]->rxBufferIndex = 0;
i2cMap[i2c]->rxBufferLength = bytesRead;
return bytesRead;
}
extern "C" uint32_t HAL_Timer_Get_Micro_Seconds()
{
return HAL_Timer_Get_Milli_Seconds()*1000;
}
uint16_t system_button_pushed_duration(uint8_t button, void*)
{
if (button || network.listening())
return 0;
return buttonPushed ? HAL_Timer_Get_Milli_Seconds()-buttonPushed : 0;
}
