static void dbg_memspy_init() { // initial state of the analyzed memory
bmp_printf(FONT_MED, 10,10, "memspy init @ f:%x ... (l:+%x) ... t:%x", mem_spy_start, mem_spy_len, mem_spy_start + mem_spy_len * 4);
SleepTask(1000);
//debug_log("memspy init @ from:%x ... (len:%x) ... to:%x", mem_spy_start, mem_spy_len, mem_spy_start + mem_spy_len * 4);
//mem_spy_len is number of int32's
if (!dbg_memmirror) dbg_memmirror = AllocateMemory(mem_spy_len*4 + 100); // local copy of mem area analyzed
if (!dbg_memmirror) return;
if (!dbg_memchanges) dbg_memchanges = AllocateMemory(mem_spy_len*4 + 100); // local copy of mem area analyzed
if (!dbg_memchanges) return;
//if (!dbg_memlogged) dbg_memlogged = AllocateMemory(mem_spy_len*4 + 100); // is this change logged
//if (!dbg_memlogged) return;
int i;
int crc = 0;
for (i = 0; i < mem_spy_len; i++) {
unsigned int addr = dbg_memspy_get_addr(i);
dbg_memmirror[i] = MEMX(addr);
dbg_memchanges[i] = 0;
//dbg_memlogged[i] = 0;
crc += dbg_memmirror[i];
}
bmp_printf(FONT_MED, 10,10, "memspy OK: %x", crc);
//debug_log("memspy OK: %x", crc);
_tic();
SleepTask(1000);
}
void led_flash(int duration) {
eventproc_EdLedOn();
SleepTask(EVENT_WAIT);
SleepTask(duration);
eventproc_EdLedOff();
SleepTask(EVENT_WAIT);
}
void memspy_task( void* unused )
{
debug_log("memspy task starting.");
while ( 1 ) {
if (mem_spy) {
SleepTask(10);
LEDBLUE ^= 2;
dbg_memspy_update();
} else {
SleepTask(1000);
}
}
debug_log("memspy task finishing.");
}
int send_to_intercom(int message, int parm) {
int result, length = 1;
switch (message) {
case IC_SET_AE:
status.ignore_msg = IC_SETTINGS_0;
break;
case IC_SET_AV_VAL:
case IC_SET_TV_VAL:
status.ignore_msg = message;
break;
case IC_RELEASE:
case IC_SET_REALTIME_ISO_0:
case IC_SET_REALTIME_ISO_1:
length = 0;
break;
case IC_SET_ISO:
case IC_SET_AF_POINT:
case IC_SET_COLOR_TEMP:
length = 2;
break;
}
result = SendToIntercom(message, length, parm);
SleepTask(INTERCOM_WAIT);
return result;
}
void menu_create(menu_t *menu) {
beep();
//GUI_Command(4,0);
//press_button(IC_BUTTON_MENU);
SendToMC(6, 2, 0);
SleepTask(100);
FLAG_GUI_MODE = 0x2D; // In theory, we do not need this, but menu_close does not work properly without it...
//DPData.gui_mode = 0x2D; // this is not the same as FLAG_GUI_MODE, but so far i do not see what it does
current_menu = menu;
menu_DPData = DPData;
menu_destroy();
menu_initialize();
GUI_Lock();
GUI_PalleteInit();
menu_handler = dialog_create(22, menu_event_handler);
//*(int*)((int)(menu_handler+0x58)) = (int)hack_central_handler;
//*(int*)((int)(menu_handler+0x7C)) = (int)menu_event_handler;
PalettePush();
PaletteChange(current_menu->color);
menu_event_display();
GUI_UnLock();
GUI_PalleteUnInit();
}
void beep() {
if (DPData.beep) {
eventproc_RiseEvent("RequestBuzzer");
SleepTask(EVENT_WAIT);
}
led_flash(BEEP_LED_LENGTH);
}
int remote_on() {
int result = eventproc_RemOn();
// disable MLU, since it's not working correctly with IR
send_to_intercom(IC_SET_CF_MIRROR_UP_LOCK, 0);
SleepTask(EVENT_WAIT);
return result;
}
void menu_repeat(menu_t *menu, void (*action)(menu_t *menu, const int repeating)){
int delay;
int button = status.button_down;
SleepTask(AUTOREPEAT_DELAY_UNIT);
action(menu, false);
delay = AUTOREPEAT_DELAY_LONG;
do {
SleepTask(AUTOREPEAT_DELAY_UNIT);
if (--delay == 0) {
action(menu, true);
delay = AUTOREPEAT_DELAY_SHORT;
}
} while (status.button_down && status.button_down == button);
}
void msm_stop(void) {
wait_for_camera();
SleepTask(RELEASE_WAIT);
send_to_intercom(IC_SET_TV_VAL, msm_tv_return);
send_to_intercom(IC_SET_AV_VAL, msm_av_return);
send_to_intercom(IC_SET_AE, msm_ae_return);
enqueue_action(msm_reset);
}
static void mem_dumper_task() {
int i;
beep();
for (i=0; i<10; i++) {
LEDBLUE ^= 2;
SleepTask(500);
}
dump_memory();
}
int shutter_release() {
wait_for_camera();
lock_sutter ();
int result = press_button(IC_BUTTON_FULL_SHUTTER);
if (DPData.drive == DRIVE_MODE_TIMER)
SleepTask(SELF_TIMER_MS);
wait_for_shutter();
return result;
}
void msm_register(void) {
static int last_flag; // Last value registered can be deleted
static tv_t last_tv; // Last Tv value registered
static av_t last_av; // Last Av value registered
int ts_start = timestamp();
if (status.measuring) {
if (status.msm_count < 8) {
status.vf_status = VF_STATUS_MSM;
send_to_intercom(IC_SET_BURST_COUNTER, status.msm_count + 1);
}
beep();
}
while (status.button_down == BUTTON_DOWN) {
if (timestamp() - ts_start > MSM_TIMEOUT) {
if (last_flag) {
status.msm_count--;
status.msm_tv -= last_tv;
status.msm_av -= last_av;
last_flag = FALSE;
send_to_intercom(IC_SET_BURST_COUNTER, status.msm_count);
beep();
}
return;
}
SleepTask(MSM_RETRY);
}
status.msm_count++;
status.msm_tv += status.measured_tv;
status.msm_av += status.measured_av;
last_flag = TRUE;
last_tv = status.measured_tv;
last_av = status.measured_av;
}
// this is a disassembled version of eventproc_release()
int shutter_release_disasm() {
extern char * aRelSem;
if (hRelSem == 0) {
hRelSem = CreateBinarySemaphore(aRelSem, 0);
}
SendToIntercom(IC_RELEASE, 0, 0);
SendToIntercom(0x6D, 1, 1); // set burst counter
TakeSemaphore(hRelSem, 30000);
DeleteSemaphore(hRelSem);
hRelSem = 0;
SleepTask(EVENT_WAIT); // we added this
return 0;
}
int shutter_release_bulb(int time) {
static int first = true;
int button;
long delay;
int shutter_lag, mirror_lag;
if (first) {
first = false;
shutter_lag = SHUTTER_LAG_1ST;
mirror_lag = MIRROR_LAG_1ST;
} else {
shutter_lag = SHUTTER_LAG_2ND;
mirror_lag = MIRROR_LAG_2ND;
}
if (DPData.drive == DRIVE_MODE_TIMER) {
button = IC_BUTTON_FULL_SHUTTER;
delay = time + shutter_lag + mirror_lag;
} else {
button = IC_BUTTON_HALF_SHUTTER;
delay = time + shutter_lag;
}
wait_for_camera();
lock_sutter ();
press_button(button);
SleepTask (delay);
press_button(button);
wait_for_shutter();
return 0;
}
int display_on() {
int result = SetTurnDisplayEvent_1_after_2();
SleepTask(EVENT_WAIT);
return result;
}
void wait_for_shutter(void) {
while (shutter_lock)
SleepTask(RELEASE_WAIT);
}
void wait_for_camera() {
while (! able_to_release())
SleepTask(RELEASE_WAIT);
}
void memspy_disable() {
mem_spy=0;
SleepTask(100);
LEDBLUE = LEDOFF;
}
int print_icu_info() {
int result = eventproc_PrintICUInfo();
SleepTask(EVENT_WAIT);
return result;
}
int display_off() {
int result = SetTurnDisplayEvent_2_after_1();
SleepTask(EVENT_WAIT);
return result;
}
int press_button(int button) {
int result = IntercomHandlerButton(button, 0); // takes 2 args...
SleepTask(EVENT_WAIT);
return result;
}
int remote_off() {
int result = eventproc_RemOff();
SleepTask(EVENT_WAIT);
return result;
}
