Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
// Copyright 2014 Emilie Gillet.
//
// Author: Emilie Gillet (emilie.o.gillet@gmail.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// See http://creativecommons.org/licenses/MIT/ for more information.
#include "stmlib/system/bootloader_utils.h"
#include "stmlib/system/system_clock.h"
#include "clouds/drivers/codec.h"
#include "clouds/drivers/leds.h"
#include "clouds/drivers/switches.h"
#include "clouds/drivers/system.h"
#include "clouds/drivers/version.h"
#include "clouds/meter.h"
#include "stm_audio_bootloader/qpsk/packet_decoder.h"
#include "stm_audio_bootloader/qpsk/demodulator.h"
#include <cstring>
using namespace clouds;
using namespace stmlib;
using namespace stm_audio_bootloader;
const double kSampleRate = 48000.0;
const double kModulationRate = 6000.0;
const double kBitRate = 12000.0;
const uint32_t kStartAddress = 0x08008000;
Codec codec;
Meter meter;
Leds leds;
Switches switches;
PacketDecoder decoder;
Demodulator demodulator;
int __errno;
// Default interrupt handlers.
extern "C" {
void NMI_Handler() { }
void HardFault_Handler() { while (1); }
void MemManage_Handler() { while (1); }
void BusFault_Handler() { while (1); }
void UsageFault_Handler() { while (1); }
void SVC_Handler() { }
void DebugMon_Handler() { }
void PendSV_Handler() { }
}
extern "C" {
const int16_t lut_db[] = {
-32768, -32768, -24576, -19783, -16384, -13746, -11591, -9770,
-8192, -6799, -5554, -4428, -3399, -2453, -1578, -762,
0, 716, 1392, 2031, 2637, 3213, 3763, 4289,
4792, 5274, 5738, 6184, 6613, 7028, 7429, 7816,
8192, 8555, 8908, 9251, 9584, 9907, 10223, 10530,
10829, 11121, 11405, 11683, 11955, 12221, 12481, 12735,
12984, 13227, 13466, 13700, 13930, 14155, 14376, 14592,
14805, 15015, 15220, 15422, 15621, 15816, 16008, 16197,
16384, 16567, 16747, 16925, 17100, 17273, 17443, 17610,
17776, 17939, 18099, 18258, 18415, 18569, 18722, 18872,
19021, 19168, 19313, 19456, 19597, 19737, 19875, 20012,
20147, 20281, 20413, 20543, 20673, 20800, 20927, 21052,
21176, 21298, 21419, 21539, 21658, 21776, 21892, 22007,
22122, 22235, 22347, 22458, 22568, 22676, 22784, 22891,
22997, 23102, 23207, 23310, 23412, 23514, 23614, 23714,
23813, 23911, 24008, 24105, 24200, 24295, 24389, 24483,
24576, 24667, 24759, 24849, 24939, 25028, 25117, 25205,
25292, 25379, 25465, 25550, 25635, 25719, 25802, 25885,
25968, 26049, 26131, 26211, 26291, 26371, 26450, 26529,
26607, 26684, 26761, 26838, 26914, 26989, 27064, 27139,
27213, 27286, 27360, 27432, 27505, 27576, 27648, 27719,
27789, 27860, 27929, 27999, 28067, 28136, 28204, 28272,
28339, 28406, 28473, 28539, 28605, 28670, 28735, 28800,
28865, 28929, 28992, 29056, 29119, 29181, 29244, 29306,
29368, 29429, 29490, 29551, 29611, 29671, 29731, 29791,
29850, 29909, 29968, 30026, 30084, 30142, 30199, 30257,
30314, 30370, 30427, 30483, 30539, 30594, 30650, 30705,
30760, 30814, 30868, 30923, 30976, 31030, 31083, 31136,
31189, 31242, 31294, 31347, 31399, 31450, 31502, 31553,
31604, 31655, 31706, 31756, 31806, 31856, 31906, 31955,
32005, 32054, 32103, 32152, 32200, 32248, 32297, 32345,
32392, 32440, 32487, 32534, 32581, 32628, 32675, 32721,
32721,
};
enum UiState {
UI_STATE_WAITING,
UI_STATE_RECEIVING,
UI_STATE_ERROR,
UI_STATE_WRITING
};
volatile bool switch_released = false;
volatile UiState ui_state;
void UpdateLeds() {
leds.Clear();
leds.set_freeze(true);
switch (ui_state) {
case UI_STATE_WAITING:
leds.set_freeze(system_clock.milliseconds() & 128);
break;
case UI_STATE_RECEIVING:
leds.set_freeze(system_clock.milliseconds() & 32);
leds.PaintBar(lut_db[meter.peak() >> 7]);
break;
case UI_STATE_ERROR:
{
bool on = system_clock.milliseconds() & 256;
for (uint8_t i = 0; i < 4; ++i) {
leds.set_status(i, on ? 255 : 0, 0);
}
}
break;
case UI_STATE_WRITING:
{
for (uint8_t i = 0; i < 4; ++i) {
leds.set_status(i, 0, 255);
}
}
break;
}
leds.Write();
}
void SysTick_Handler() {
system_clock.Tick();
switches.Debounce();
if (switches.released(2)) {
switch_released = true;
}
UpdateLeds();
}
}
size_t discard_samples = 8000;
void FillBuffer(Codec::Frame* input, Codec::Frame* output, size_t n) {
meter.Process(input, n);
while (n--) {
int32_t sample = (input->l >> 4) + 2048;
if (!discard_samples) {
demodulator.PushSample(sample);
} else {
--discard_samples;
}
*output = *input;
++output;
++input;
}
}
static size_t current_address;
static uint16_t packet_index;
static uint32_t kSectorBaseAddress[] = {
0x08000000,
0x08004000,
0x08008000,
0x0800C000,
0x08010000,
0x08020000,
0x08040000,
0x08060000,
0x08080000,
0x080A0000,
0x080C0000,
0x080E0000
};
const uint32_t kBlockSize = 16384;
const uint16_t kPacketsPerBlock = kBlockSize / kPacketSize;
uint8_t rx_buffer[kBlockSize];
void ProgramPage(const uint8_t* data, size_t size) {
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
for (int32_t i = 0; i < 12; ++i) {
if (current_address == kSectorBaseAddress[i]) {
FLASH_EraseSector(i * 8, VoltageRange_3);
}
}
const uint32_t* words = static_cast<const uint32_t*>(
static_cast<const void*>(data));
for (size_t written = 0; written < size; written += 4) {
FLASH_ProgramWord(current_address, *words++);
current_address += 4;
}
}
void Init() {
System sys;
Version version;
sys.Init(false);
leds.Init();
meter.Init(48000);
switches.Init();
version.Init();
if (!codec.Init(!version.revised(), 48000)) { }
if (!codec.Start(32, &FillBuffer)) { }
sys.StartTimers();
}
void InitializeReception() {
decoder.Init(20000);
demodulator.Init(
kModulationRate / kSampleRate * 4294967296.0,
kSampleRate / kModulationRate,
2.0 * kSampleRate / kBitRate);
demodulator.SyncCarrier(true);
decoder.Reset();
current_address = kStartAddress;
packet_index = 0;
ui_state = UI_STATE_WAITING;
}
int main(void) {
InitializeReception();
Init();
bool exit_updater = !switches.pressed_immediate(2);
while (!exit_updater) {
bool error = false;
if (demodulator.state() == DEMODULATOR_STATE_OVERFLOW) {
error = true;
} else {
demodulator.ProcessAtLeast(32);
}
while (demodulator.available() && !error && !exit_updater) {
uint8_t symbol = demodulator.NextSymbol();
PacketDecoderState state = decoder.ProcessSymbol(symbol);
switch (state) {
case PACKET_DECODER_STATE_OK:
{
ui_state = UI_STATE_RECEIVING;
memcpy(
rx_buffer + (packet_index % kPacketsPerBlock) * kPacketSize,
decoder.packet_data(),
kPacketSize);
++packet_index;
if ((packet_index % kPacketsPerBlock) == 0) {
ui_state = UI_STATE_WRITING;
ProgramPage(rx_buffer, kBlockSize);
decoder.Reset();
demodulator.SyncCarrier(false);
} else {
decoder.Reset();
demodulator.SyncDecision();
}
}
break;
case PACKET_DECODER_STATE_ERROR_SYNC:
case PACKET_DECODER_STATE_ERROR_CRC:
error = true;
break;
case PACKET_DECODER_STATE_END_OF_TRANSMISSION:
exit_updater = true;
break;
default:
break;
}
}
if (error) {
ui_state = UI_STATE_ERROR;
switch_released = false;
while (!switch_released); // Polled in ISR
InitializeReception();
}
}
codec.Stop();
Uninitialize();
JumpTo(kStartAddress);
while (1) { }
}
08460a69aThis file is pinned to the selected release. Download the original to open it in your design tool.