mirror of
https://github.com/eried/portapack-mayhem.git
synced 2024-09-20 16:15:51 +00:00
6bcb7dc1b1
# The first commit's message is: Updated RDS transmitter: flags, PI and date/time Merging baseband audio tone generators Merging DTMF baseband with "tones" baseband Added stealth transmit mode App flash section bumped to 512k RX and TX LEDs are now used Play dead should work again, added login option Morse frame gen. for letters and fox hunt codes Merged EPAR with Xylos Made EPAR use encoders for frame gen. Moved OOK encoders data in encoders.hpp Simplified about screen, ui_about_demo.* files are still there BHT city DB, keywords removed BHT cities DB, keywords removed Update README.md RDS radiotext and time group generators # This is the 2nd commit message: Update README.md
419 lines
9.9 KiB
C++
419 lines
9.9 KiB
C++
/*
|
|
* Copyright (C) 2015 Jared Boone, ShareBrained Technology, Inc.
|
|
* Copyright (C) 2016 Furrtek
|
|
*
|
|
* This file is part of PortaPack.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <ch.h>
|
|
|
|
#include "demofont.hpp"
|
|
#include "ymdata.hpp"
|
|
|
|
#include "cpld_update.hpp"
|
|
#include "portapack.hpp"
|
|
#include "audio.hpp"
|
|
#include "event_m0.hpp"
|
|
|
|
#include "ui_about.hpp"
|
|
#include "touch.hpp"
|
|
#include "sine_table.hpp"
|
|
|
|
#include "portapack_shared_memory.hpp"
|
|
#include "portapack_persistent_memory.hpp"
|
|
#include "lpc43xx_cpp.hpp"
|
|
|
|
#include <math.h>
|
|
#include <cstring>
|
|
|
|
using namespace lpc43xx;
|
|
using namespace portapack;
|
|
|
|
namespace ui {
|
|
|
|
void AboutView::on_show() {
|
|
transmitter_model.set_tuning_frequency(1337000000); // TODO: Change
|
|
transmitter_model.set_baseband_configuration({
|
|
.mode = 0,
|
|
.sampling_rate = 1536000,
|
|
.decimation_factor = 1,
|
|
});
|
|
transmitter_model.set_rf_amp(true);
|
|
transmitter_model.set_lna(40);
|
|
transmitter_model.set_vga(40);
|
|
transmitter_model.set_baseband_bandwidth(1750000);
|
|
transmitter_model.enable();
|
|
|
|
baseband::set_audiotx_data(32, 50, false, 0);
|
|
|
|
//audio::headphone::set_volume(volume_t::decibel(0 - 99) + audio::headphone::volume_range().max);
|
|
}
|
|
|
|
void AboutView::render_video() {
|
|
uint8_t p, r, luma, chroma, cy;
|
|
ui::Color cc;
|
|
char ch;
|
|
float s;
|
|
|
|
// Send framebuffer to LCD. Gotta go fast !
|
|
display.render_box({30, 112}, {180, 72}, framebuffer);
|
|
|
|
// Clear framebuffer to black
|
|
memset(framebuffer, 0, 180 * 72 * sizeof(ui::Color));
|
|
|
|
// Drum hit palette animation
|
|
if (drum > 1) drum--;
|
|
|
|
// Render copper bars from Y buffer
|
|
for (p = 0; p < 72; p++) {
|
|
luma = copperbuffer[p] & 0x0F; // 0 is transparent
|
|
if (luma) {
|
|
chroma = copperbuffer[p]>>4;
|
|
cc = ui::Color(std::min((coppercolor[chroma][0]/luma)*drum,255), std::min((coppercolor[chroma][1]/luma)*drum,255), std::min((coppercolor[chroma][2]/luma)*drum,255));
|
|
for (r = 0; r < 180; r++)
|
|
framebuffer[(p*180)+r] = cc;
|
|
}
|
|
}
|
|
|
|
// Scroll in/out state machine
|
|
if (anim_state == 0) {
|
|
// Scroll in
|
|
if (ofy < 8) {
|
|
ofy++;
|
|
anim_state = 0;
|
|
} else {
|
|
anim_state = 1;
|
|
}
|
|
if (ofx < (int16_t)(180 - (strlen(credits[credits_index].name) * 16) - 8)) {
|
|
ofx += 8;
|
|
anim_state = 0;
|
|
}
|
|
} else if (anim_state == 1) {
|
|
// Just wait
|
|
if (credits_timer == (30*3)) {
|
|
credits_timer = 0;
|
|
anim_state = 2;
|
|
} else {
|
|
credits_timer++;
|
|
}
|
|
} else {
|
|
// Scroll out
|
|
if (credits[credits_index].change == true) {
|
|
if (ofy > -24) {
|
|
ofy--;
|
|
anim_state = 2;
|
|
} else {
|
|
anim_state = 0;
|
|
}
|
|
} else {
|
|
anim_state = 0;
|
|
}
|
|
if (ofx < 180) {
|
|
ofx += 8;
|
|
anim_state = 2;
|
|
}
|
|
|
|
// Switch to next text
|
|
if (anim_state == 0) {
|
|
if (credits_index == 9)
|
|
credits_index = 0;
|
|
else
|
|
credits_index++;
|
|
ofx = -(strlen(credits[credits_index].name) * 16) - 16;
|
|
}
|
|
}
|
|
|
|
// Sine text ("role")
|
|
p = 0;
|
|
while ((ch = credits[credits_index].role[p])) {
|
|
draw_demoglyph({(ui::Coord)(8+(p*16)), (ui::Coord)(ofy+(sine_table_f32[((p*16)+(phase>>5))&0xFF] * 8))}, ch, paletteA);
|
|
p++;
|
|
}
|
|
|
|
// Scroll text (name)
|
|
p = 0;
|
|
while ((ch = credits[credits_index].name[p])) {
|
|
draw_demoglyph({(ui::Coord)(ofx+(p*16)), 56}, ch, paletteB);
|
|
p++;
|
|
}
|
|
|
|
// Clear bars Y buffer
|
|
memset(copperbuffer, 0, 72);
|
|
|
|
// Render bars to Y buffer
|
|
for (p = 0; p < 5; p++) {
|
|
cy = copperbars[p];
|
|
for (r = 0; r < 16; r++)
|
|
copperbuffer[cy+r] = copperluma[r] + (p<<4);
|
|
}
|
|
|
|
// Animate bars positions
|
|
for (p = 0; p < 5; p++) {
|
|
s = sine_table_f32[((p*32)+(phase/24))&0xFF];
|
|
s += sine_table_f32[((p*16)+(phase/35))&0xFF];
|
|
copperbars[p] = 28+(uint8_t)(s * 14);
|
|
}
|
|
|
|
phase += 128;
|
|
}
|
|
|
|
void AboutView::draw_demoglyph(ui::Point p, char ch, ui::Color * pal) {
|
|
uint8_t x, y, c, cl, cr;
|
|
uint16_t che;
|
|
int16_t lbx, il;
|
|
|
|
// Map ASCII to font bitmap
|
|
if ((ch >= 32) || (ch < 96))
|
|
che = char_map[ch-32];
|
|
else
|
|
che = 0xFF;
|
|
|
|
if (che < 0xFF) {
|
|
che = (che * 128) + 48; // Start in bitmap
|
|
|
|
il = (180 * p.y) + p.x; // Start il framebuffer
|
|
|
|
for (y = 0; y < 16; y++) {
|
|
if (p.y + y >= 72) break; // Over bottom of framebuffer, abort
|
|
if (p.y + y >= 0) {
|
|
for (x = 0; x < 8; x++) {
|
|
c = demofont_bin[x+(y*8)+che]; // Split byte in 2 4BPP pixels
|
|
cl = c >> 4;
|
|
cr = c & 0x0F;
|
|
lbx = p.x + (x*2);
|
|
if (cl && (lbx < 180) && (lbx >= 0)) framebuffer[il] = pal[cl];
|
|
lbx++;
|
|
il++;
|
|
if (cr && (lbx < 180) && (lbx >= 0)) framebuffer[il] = pal[cr];
|
|
il++;
|
|
}
|
|
il += 180-16;
|
|
} else {
|
|
il += 180;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AboutView::render_audio() {
|
|
uint8_t i, ymdata;
|
|
uint16_t ym_render_cnt;
|
|
|
|
// This is heavily inspired by MAME's ay8910.cpp and the YM2149's datasheet
|
|
|
|
// Render 1024 music samples
|
|
for (ym_render_cnt = 0; ym_render_cnt < 1024; ym_render_cnt++) {
|
|
|
|
// Update registers at 48000/960 = 50Hz
|
|
if (ym_sample_cnt == 0) {
|
|
// "Decompress" on the fly and update YM registers
|
|
for (i = 0; i < 14; i++) {
|
|
if (!ym_regs[i].cnt) {
|
|
// New run
|
|
ymdata = ymdata_bin[ym_regs[i].ptr++];
|
|
ym_regs[i].cnt = ymdata & 0x7F;
|
|
if (ymdata & 0x80) {
|
|
ym_regs[i].same = true;
|
|
ym_regs[i].value = ymdata_bin[ym_regs[i].ptr++];
|
|
} else {
|
|
ym_regs[i].same = false;
|
|
}
|
|
// Detect drum on channel B
|
|
if (i == 3)
|
|
if (ym_regs[3].value > 2) drum = 4;
|
|
}
|
|
if (ym_regs[i].same == false) {
|
|
ym_regs[i].value = ymdata_bin[ym_regs[i].ptr++];
|
|
if (i == 13) {
|
|
// Update envelope attributes
|
|
ym_env_att = (ym_regs[13].value & 4) ? 0x1F : 0x00;
|
|
if (!(ym_regs[13].value & 8)) {
|
|
ym_env_hold = 1;
|
|
ym_env_alt = ym_env_att;
|
|
} else {
|
|
ym_env_hold = ym_regs[13].value & 1;
|
|
ym_env_alt = ym_regs[13].value & 2;
|
|
}
|
|
// Reset envelope counter
|
|
ym_env_step = 0x1F;
|
|
ym_env_holding = 0;
|
|
ym_env_vol = (ym_env_step ^ ym_env_att);
|
|
}
|
|
}
|
|
ym_regs[i].cnt--;
|
|
}
|
|
ym_frame++;
|
|
}
|
|
|
|
// Square wave oscillators
|
|
// 2457600/16/48000 = 3.2, but 4 sounds better than 3...
|
|
for (i = 0; i < 3; i++) {
|
|
ym_osc_cnt[i] += 4;
|
|
if (ym_osc_cnt[i] >= (ym_regs[i*2].value | ((ym_regs[(i*2)+1].value & 0x0f) << 8))) {
|
|
ym_osc_cnt[i] = 0;
|
|
ym_osc_out[i] ^= 1;
|
|
}
|
|
}
|
|
|
|
// Noise generator
|
|
ym_noise_cnt += 4;
|
|
if (ym_noise_cnt >= ((ym_regs[6].value & 0x1F) * 2)) {
|
|
ym_noise_cnt = 0;
|
|
ym_rng ^= (((ym_rng & 1) ^ ((ym_rng >> 3) & 1)) << 17);
|
|
ym_rng >>= 1;
|
|
}
|
|
|
|
// Mix tones and noise
|
|
for (i = 0; i < 3; i++)
|
|
ym_ch[i] = (ym_osc_out[i] | ((ym_regs[7].value >> i) & 1)) & ((ym_rng & 1) | ((ym_regs[7].value >> (i + 3)) & 1));
|
|
|
|
// Envelope generator
|
|
if (!ym_env_holding) {
|
|
ym_env_cnt += 8;
|
|
if (ym_env_cnt >= (ym_regs[11].value | (ym_regs[12].value<<8))) {
|
|
ym_env_cnt = 0;
|
|
ym_env_step--;
|
|
if (ym_env_step < 0) {
|
|
if (ym_env_hold) {
|
|
if (ym_env_alt)
|
|
ym_env_att ^= 0x1F;
|
|
ym_env_holding = 1;
|
|
ym_env_step = 0;
|
|
} else {
|
|
if (ym_env_alt && (ym_env_step & 0x20))
|
|
ym_env_att ^= 0x1F;
|
|
ym_env_step &= 0x1F;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ym_env_vol = (ym_env_step ^ ym_env_att);
|
|
|
|
ym_out = 0;
|
|
for (i = 0; i < 3; i++) {
|
|
if (ym_regs[i + 8].value & 0x10) {
|
|
// Envelope mode
|
|
ym_out += (ym_ch[i] ? ym_env_vol : 0);
|
|
} else {
|
|
// Fixed mode
|
|
ym_out += (ym_ch[i] ? (ym_regs[i + 8].value & 0x0F) : 0);
|
|
}
|
|
}
|
|
|
|
ym_buffer[ym_render_cnt] = (ym_out * 2) - 45;
|
|
|
|
if (ym_sample_cnt < 960) {
|
|
ym_sample_cnt++;
|
|
} else {
|
|
ym_sample_cnt = 0;
|
|
}
|
|
|
|
// Loop
|
|
if (ym_frame == ym_frames) ym_init();
|
|
}
|
|
}
|
|
|
|
void AboutView::update() {
|
|
if (framebuffer) {
|
|
// Update 1 out of 2 frames, 60Hz is very laggy
|
|
if (refresh_cnt & 1) render_video();
|
|
refresh_cnt++;
|
|
}
|
|
|
|
// Slowly increase volume to avoid jumpscare
|
|
if (headphone_vol < (70 << 2)) {
|
|
audio::headphone::set_volume(volume_t::decibel((headphone_vol/4) - 99) + audio::headphone::volume_range().max);
|
|
headphone_vol++;
|
|
}
|
|
}
|
|
|
|
void AboutView::ym_init() {
|
|
uint8_t reg;
|
|
|
|
for (reg = 0; reg < 14; reg++) {
|
|
ym_regs[reg].cnt = 0;
|
|
// Pick up start pointers for each YM registers RLE blocks
|
|
ym_regs[reg].ptr = ((uint16_t)(ymdata_bin[(reg*2)+3])<<8) + ymdata_bin[(reg*2)+2];
|
|
ym_regs[reg].same = false; // Useless ?
|
|
ym_regs[reg].value = 0; // Useless ?
|
|
}
|
|
|
|
ym_frame = 0;
|
|
}
|
|
|
|
AboutView::AboutView(
|
|
NavigationView& nav
|
|
)
|
|
{
|
|
uint8_t p, c;
|
|
|
|
baseband::run_image(portapack::spi_flash::image_tag_audio_tx);
|
|
|
|
add_children({ {
|
|
&text_title,
|
|
&text_firmware,
|
|
&text_cpld_hackrf,
|
|
&text_cpld_hackrf_status,
|
|
&button_ok,
|
|
} });
|
|
|
|
if( cpld_hackrf_verify_eeprom() ) {
|
|
text_cpld_hackrf_status.set(" OK");
|
|
} else {
|
|
text_cpld_hackrf_status.set("BAD");
|
|
}
|
|
|
|
// Politely ask for about 26kB
|
|
framebuffer = (ui::Color *)chHeapAlloc(0x0, 180 * 72 * sizeof(ui::Color));
|
|
|
|
if (framebuffer) {
|
|
memset(framebuffer, 0, 180 * 72 * sizeof(ui::Color));
|
|
|
|
// Copy original font palette
|
|
c = 0;
|
|
for (p = 0; p < 48; p+=3)
|
|
paletteA[c++] = ui::Color(demofont_bin[p], demofont_bin[p+1], demofont_bin[p+2]);
|
|
|
|
// Increase red in another one
|
|
c = 0;
|
|
for (p = 0; p < 48; p+=3)
|
|
paletteB[c++] = ui::Color(std::min(demofont_bin[p]+64, 255), demofont_bin[p+1], demofont_bin[p+2]);
|
|
}
|
|
|
|
// Init YM synth
|
|
ym_frames = ((uint16_t)(ymdata_bin[1])<<8) + ymdata_bin[0];
|
|
ym_init();
|
|
|
|
|
|
button_ok.on_select = [this,&nav](Button&){
|
|
if (framebuffer) chHeapFree(framebuffer); // Do NOT forget this
|
|
nav.pop();
|
|
};
|
|
}
|
|
|
|
AboutView::~AboutView() {
|
|
transmitter_model.disable();
|
|
baseband::shutdown();
|
|
}
|
|
|
|
void AboutView::focus() {
|
|
button_ok.focus();
|
|
}
|
|
|
|
} /* namespace ui */
|