neil/Flipper
1
0
Fork 0
mirror of https://github.com/UberGuidoZ/Flipper.git synced 2025-01-03 12:20:15 +00:00
Code Issues Packages Projects Releases Wiki Activity
bc79952b69
Flipper/Applications/Official/source-OLDER/grnch/wii_ec_anal/wii_anal.c

544 lines
18 KiB
C
Raw Blame History

//----------------------------------------------------------------------------- ----------------------------------------
// Includes
//
// System libs
#include <stdlib.h> // malloc
#include <stdint.h> // uint32_t
#include <stdarg.h> // __VA_ARGS__
#include <stdio.h>
#include <ctype.h>
// FlipperZero libs
#include <furi.h> // Core API
#include <gui/gui.h> // GUI (screen/keyboard) API
#include <input/input.h> // GUI Input extensions
#include <notification/notification_messages.h>
// Do this first!
#define ERR_C_ // Do this in precisely ONE file
#include "err.h" // Error numbers & messages
#include "bc_logging.h"
// Local headers
#include "wii_anal.h" // Various enums and struct declarations
#include "wii_i2c.h" // Wii i2c functions
#include "wii_ec.h" // Wii Extension Controller functions (eg. draw)
#include "wii_anal_keys.h" // key mappings
#include "gfx/images.h" // Images
#include "wii_anal_lcd.h" // Drawing functions
#include "wii_anal_ec.h" // Wii controller events
#include "wii_anal_ver.h" // Version number
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// OOOOO // SSSSS CCCCC AAA L L BBBB AAA CCCC K K SSSSS
// O O /// S C A A L L B B A A C K K S
// O O /// SSSSS C AAAAA L L BBBB AAAAA C KKK SSSSS
// O O /// S C A A L L B B A A C K K S
// OOOOO // SSSSS CCCCC A A LLLLL LLLLL BBBB A A CCCC K K SSSSS
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//+============================================================================ ========================================
// OS Callback : Timer tick
// We register this function to be called when the OS signals a timer 'tick' event
//
static void cbTimer(FuriMessageQueue* queue) {
ENTER;
furi_assert(queue);
eventMsg_t message = {.id = EVID_TICK};
furi_message_queue_put(queue, &message, 0);
LEAVE;
return;
}
//+============================================================================ ========================================
// OS Callback : Keypress
// We register this function to be called when the OS detects a keypress
//
static void cbInput(InputEvent* event, FuriMessageQueue* queue) {
ENTER;
furi_assert(queue);
furi_assert(event);
// Put an "input" event message on the message queue
eventMsg_t message = {.id = EVID_KEY, .input = *event};
furi_message_queue_put(queue, &message, FuriWaitForever);
LEAVE;
return;
}
//+============================================================================
// Show version number
//
static void showVer(Canvas* const canvas) {
show(canvas, 0, 59, &img_3x5_v, SHOW_SET_BLK);
show(canvas, 4, 59, VER_MAJ, SHOW_SET_BLK);
canvas_draw_frame(canvas, 8, 62, 2, 2);
show(canvas, 11, 59, VER_MIN, SHOW_SET_BLK);
}
//+============================================================================
// OS Callback : Draw request
// We register this function to be called when the OS requests that the screen is redrawn
//
// We actually instruct the OS to perform this request, after we update the interface
// I guess it's possible that this instruction may able be issued by other threads !?
//
static void cbDraw(Canvas* const canvas, void* ctx) {
ENTER;
furi_assert(canvas);
furi_assert(ctx);
state_t* state = NULL;
// Try to acquire the mutex for the plugin state variables, timeout = 25mS
if(!(state = (state_t*)acquire_mutex((ValueMutex*)ctx, 25))) return;
switch(state->scene) {
//---------------------------------------------------------------------
case SCENE_SPLASH:
show(canvas, 2, 0, &img_csLogo_FULL, SHOW_SET_BLK);
canvas_set_font(canvas, FontSecondary);
canvas_draw_str_aligned(canvas, 64, 43, AlignCenter, AlignTop, "Wii Extension Controller");
canvas_draw_str_aligned(canvas, 64, 55, AlignCenter, AlignTop, "Protocol Analyser");
showVer(canvas);
break;
//---------------------------------------------------------------------
case SCENE_RIP:
show(canvas, 0, 0, &img_RIP, SHOW_SET_BLK);
break;
//---------------------------------------------------------------------
case SCENE_WAIT:
#define xo 2
show(canvas, 3 + xo, 10, &img_ecp_port, SHOW_SET_BLK);
BOX_TL(22 + xo, 6, 82 + xo, 23); // 3v3
BOX_TL(48 + xo, 21, 82 + xo, 23); // C1
BOX_BL(22 + xo, 41, 82 + xo, 58); // C0
BOX_BL(48 + xo, 41, 82 + xo, 44); // Gnd
show(canvas, 90 + xo, 3, &img_6x8_3, SHOW_SET_BLK); // 3v3
show(canvas, 97 + xo, 3, &img_6x8_v, SHOW_SET_BLK);
show(canvas, 104 + xo, 3, &img_6x8_3, SHOW_SET_BLK);
show(canvas, 90 + xo, 18, &img_6x8_C, SHOW_SET_BLK); // C1 <->
show(canvas, 98 + xo, 18, &img_6x8_1, SHOW_SET_BLK);
show(canvas, 107 + xo, 16, &img_ecp_SDA, SHOW_SET_BLK);
show(canvas, 90 + xo, 40, &img_6x8_G, SHOW_SET_BLK); // Gnd
show(canvas, 97 + xo, 40, &img_6x8_n, SHOW_SET_BLK);
show(canvas, 104 + xo, 40, &img_6x8_d, SHOW_SET_BLK);
show(canvas, 90 + xo, 54, &img_6x8_C, SHOW_SET_BLK); // C0 _-_-
show(canvas, 98 + xo, 54, &img_6x8_0, SHOW_SET_BLK);
show(canvas, 108 + xo, 54, &img_ecp_SCL, SHOW_SET_BLK);
show(canvas, 0, 0, &img_csLogo_Small, SHOW_SET_BLK);
showVer(canvas);
#undef xo
break;
//---------------------------------------------------------------------
case SCENE_DEBUG:
canvas_set_font(canvas, FontSecondary);
show(canvas, 0, 0, &img_key_U, SHOW_SET_BLK);
canvas_draw_str_aligned(canvas, 11, 0, AlignLeft, AlignTop, "Initialise Perhipheral");
show(canvas, 0, 11, &img_key_OK, SHOW_SET_BLK);
canvas_draw_str_aligned(canvas, 11, 11, AlignLeft, AlignTop, "Read values [see log]");
show(canvas, 0, 23, &img_key_D, SHOW_SET_BLK);
canvas_draw_str_aligned(canvas, 11, 22, AlignLeft, AlignTop, "Restart Scanner");
show(canvas, 0, 33, &img_key_Back, SHOW_SET_BLK);
canvas_draw_str_aligned(canvas, 11, 33, AlignLeft, AlignTop, "Exit");
break;
//---------------------------------------------------------------------
default:
if(state->ec.pidx >= PID_ERROR) {
ERROR("%s : bad PID = %d", __func__, state->ec.pidx);
} else {
if((state->scene == SCENE_DUMP) || !ecId[state->ec.pidx].show)
ecId[PID_UNKNOWN].show(canvas, state);
else
ecId[state->ec.pidx].show(canvas, state);
}
break;
}
// Release the mutex
release_mutex((ValueMutex*)ctx, state);
LEAVE;
return;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// SSSSS TTTTT AAA TTTTT EEEEE V V AAA RRRR IIIII AAA BBBB L EEEEE SSSSS
// S T A A T E V V A A R R I A A B B L E S
// SSSSS T AAAAA T EEE V V AAAAA RRRR I AAAAA BBBB L EEE SSSSS
// S T A A T E V V A A R R I A A B B L E S
// SSSSS T A A T EEEEE V A A R R IIIII A A BBBB LLLLL EEEEE SSSSS
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//+============================================================================ ========================================
// Initialise plugin state variables
//
static inline bool stateInit(state_t* const state) {
ENTER;
furi_assert(state);
bool rv = true; // assume success
// Enable the main loop
state->run = true;
// Timer
state->timerEn = false;
state->timer = NULL;
state->timerHz = furi_kernel_get_tick_frequency();
state->fps = 30;
// Scene
state->scene = SCENE_SPLASH;
state->scenePrev = SCENE_NONE;
state->scenePegg = SCENE_NONE;
state->hold = 0; // show hold meters (-1=lowest, 0=current, +1=highest}
state->calib = CAL_TRACK;
state->pause = false; // animation running
state->apause = false; // auto-pause animation
// Notifications
state->notify = NULL;
// Perhipheral
state->ec.init = false;
state->ec.pidx = PID_UNKNOWN;
state->ec.sid = ecId[state->ec.pidx].name;
// Controller data
memset(state->ec.pid, 0xC5, PID_LEN); // Cyborg 5ystems
memset(state->ec.calF, 0xC5, CAL_LEN);
memset(state->ec.joy, 0xC5, JOY_LEN);
// Encryption details
state->ec.encrypt = false;
memset(state->ec.encKey, 0x00, ENC_LEN);
// Seed the PRNG
// CYCCNT --> lib/STM32CubeWB/Drivers/CMSIS/Include/core_cm7.h
// srand(DWT->CYCCNT);
LEAVE;
return rv;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// MM MM AAA IIIII N N
// M M M A A I NN N
// M M M AAAAA I N N N
// M M A A I N NN
// M M A A IIIII N N
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//+============================================================================ ========================================
// Enable/Disable scanning
//
void timerEn(state_t* state, bool on) {
ENTER;
furi_assert(state);
// ENable scanning
if(on) {
if(state->timerEn) {
WARN(wii_errs[WARN_SCAN_START]);
} else {
// Set the timer to fire at 'fps' times/second
if(furi_timer_start(state->timer, state->timerHz / state->fps) == FuriStatusOk) {
state->timerEn = true;
INFO("%s : monitor started", __func__);
} else {
ERROR(wii_errs[ERR_TIMER_START]);
}
}
// DISable scanning
} else {
if(!state->timerEn) {
WARN(wii_errs[WARN_SCAN_STOP]);
} else {
// Stop the timer
if(furi_timer_stop(state->timer) == FuriStatusOk) {
state->timerEn = false;
INFO("%s : monitor stopped", __func__);
} else {
ERROR(wii_errs[ERR_TIMER_STOP]);
}
}
}
LEAVE;
return;
}
//+============================================================================ ========================================
// Plugin entry point
//
int32_t wii_ec_anal(void) {
ENTER;
// ===== Variables =====
err_t error = 0; // assume success
Gui* gui = NULL;
ViewPort* vpp = NULL;
state_t* state = NULL;
ValueMutex mutex = {0};
FuriMessageQueue* queue = NULL;
const uint32_t queueSz = 20; // maximum messages in queue
uint32_t tmo = (3.5f * 1000); // timeout splash screen after N seconds
// The queue will contain plugin event-messages
// --> local
eventMsg_t msg = {0};
INFO("BEGIN");
// ===== Message queue =====
// 1. Create a message queue (for up to 8 (keyboard) event messages)
if(!(queue = furi_message_queue_alloc(queueSz, sizeof(msg)))) {
ERROR(wii_errs[(error = ERR_MALLOC_QUEUE)]);
goto bail;
}
// ===== Create GUI Interface =====
// 2. Create a GUI interface
if(!(gui = furi_record_open("gui"))) {
ERROR(wii_errs[(error = ERR_NO_GUI)]);
goto bail;
}
// ===== Plugin state variables =====
// 3. Allocate space on the heap for the plugin state variables
if(!(state = malloc(sizeof(state_t)))) {
ERROR(wii_errs[(error = ERR_MALLOC_STATE)]);
goto bail;
}
// 4. Initialise the plugin state variables
if(!stateInit(state)) {
// error message(s) is/are output by stateInit()
error = 15;
goto bail;
}
// 5. Create a mutex for (reading/writing) the plugin state variables
if(!init_mutex(&mutex, state, sizeof(state))) {
ERROR(wii_errs[(error = ERR_NO_MUTEX)]);
goto bail;
}
// ===== Viewport =====
// 6. Allocate space on the heap for the viewport
if(!(vpp = view_port_alloc())) {
ERROR(wii_errs[(error = ERR_MALLOC_VIEW)]);
goto bail;
}
// 7a. Register a callback for input events
view_port_input_callback_set(vpp, cbInput, queue);
// 7b. Register a callback for draw events
view_port_draw_callback_set(vpp, cbDraw, &mutex);
// ===== Start GUI Interface =====
// 8. Attach the viewport to the GUI
gui_add_view_port(gui, vpp, GuiLayerFullscreen);
// ===== Timer =====
// 9. Allocate a timer
if(!(state->timer = furi_timer_alloc(cbTimer, FuriTimerTypePeriodic, queue))) {
ERROR(wii_errs[(error = ERR_NO_TIMER)]);
goto bail;
}
// === System Notifications ===
// 10. Acquire a handle for the system notification queue
if(!(state->notify = furi_record_open(RECORD_NOTIFICATION))) {
ERROR(wii_errs[(error = ERR_NO_NOTIFY)]);
goto bail;
}
patBacklight(state); // Turn on the backlight [qv. remote FAP launch]
INFO("INITIALISED");
// ==================== Main event loop ====================
if(state->run) do {
bool redraw = false;
FuriStatus status = FuriStatusErrorTimeout;
// Wait for a message
// while ((status = furi_message_queue_get(queue, &msg, tmo)) == FuriStatusErrorTimeout) ;
status = furi_message_queue_get(queue, &msg, tmo);
// Clear splash screen
if((state->scene == SCENE_SPLASH) &&
(state->scenePrev == SCENE_NONE) && // Initial splash
((status == FuriStatusErrorTimeout) || // timeout
((msg.id == EVID_KEY) && (msg.input.type == InputTypeShort))) // or <any> key-short
) {
tmo = 60 * 1000; // increase message-wait timeout to 60secs
timerEn(state, true); // start scanning the i2c bus
status = FuriStatusOk; // pass status check
msg.id = EVID_NONE; // valid msg ID
sceneSet(state, SCENE_WAIT); // move to wait screen
}
// Check for queue errors
if(status != FuriStatusOk) {
switch(status) {
case FuriStatusErrorTimeout:
DEBUG(wii_errs[DEBUG_QUEUE_TIMEOUT]);
continue;
case FuriStatusError:
ERROR(wii_errs[(error = ERR_QUEUE_RTOS)]);
goto bail;
case FuriStatusErrorResource:
ERROR(wii_errs[(error = ERR_QUEUE_RESOURCE)]);
goto bail;
case FuriStatusErrorParameter:
ERROR(wii_errs[(error = ERR_QUEUE_BADPRM)]);
goto bail;
case FuriStatusErrorNoMemory:
ERROR(wii_errs[(error = ERR_QUEUE_NOMEM)]);
goto bail;
case FuriStatusErrorISR:
ERROR(wii_errs[(error = ERR_QUEUE_ISR)]);
goto bail;
default:
ERROR(wii_errs[(error = ERR_QUEUE_UNK)]);
goto bail;
}
}
// Read successful
// *** Try to lock the plugin state variables ***
if(!(state = (state_t*)acquire_mutex_block(&mutex))) {
ERROR(wii_errs[(error = ERR_MUTEX_BLOCK)]);
goto bail;
}
// *** Handle events ***
switch(msg.id) {
//---------------------------------------------
case EVID_TICK: // Timer events
//! I would prefer to have ecPoll() called by cbTimer()
//! ...but how does cbTimer() get the required access to the state variables? Namely: 'state->ec'
//! So, for now, the timer pushes a message to call ecPoll()
//! which, in turn, will push WIIEC event meesages! <facepalm>
ecPoll(&state->ec, queue);
break;
//---------------------------------------------
case EVID_WIIEC: // WiiMote Perhipheral
if(evWiiEC(&msg, state)) redraw = true;
break;
//---------------------------------------------
case EVID_KEY: // Key events
patBacklight(state);
if(evKey(&msg, state)) redraw = true;
break;
//---------------------------------------------
case EVID_NONE:
break;
//---------------------------------------------
default: // Unknown event
WARN("Unknown message.ID [%d]", msg.id);
break;
}
// *** Update the GUI screen via the viewport ***
if(redraw) view_port_update(vpp);
// *** Try to release the plugin state variables ***
if(!release_mutex(&mutex, state)) {
ERROR(wii_errs[(error = ERR_MUTEX_RELEASE)]);
goto bail;
}
} while(state->run);
// ===== Game Over =====
INFO("USER EXIT");
bail:
// 10. Release system notification queue
if(state->notify) {
furi_record_close(RECORD_NOTIFICATION);
state->notify = NULL;
}
// 9. Stop the timer
if(state->timer) {
(void)furi_timer_stop(state->timer);
furi_timer_free(state->timer);
state->timer = NULL;
state->timerEn = false;
}
// 8. Detach the viewport
gui_remove_view_port(gui, vpp);
// 7. No need to unreqgister the callbacks
// ...they will go when the viewport is destroyed
// 6. Destroy the viewport
if(vpp) {
view_port_enabled_set(vpp, false);
view_port_free(vpp);
vpp = NULL;
}
// 5. Free the mutex
if(mutex.mutex) {
delete_mutex(&mutex);
mutex.mutex = NULL;
}
// 4. Free up state pointer(s)
// none
// 3. Free the plugin state variables
if(state) {
free(state);
state = NULL;
}
// 2. Close the GUI
furi_record_close("gui");
// 1. Destroy the message queue
if(queue) {
furi_message_queue_free(queue);
queue = NULL;
}
INFO("CLEAN EXIT ... Exit code: %d", error);
LEAVE;
return (int32_t)error;
}
Reference in New Issue View Git Blame Copy Permalink