rusefi
/
rusefi-full
mirror of https://github.com/rusefi/rusefi-full.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

?

This commit is contained in:
Andrey B 2014-04-25 22:41:33 -05:00
parent 9601c88337
commit 0367b7e344
4 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
firmware/config/system/chconf.h
View File

@ -65,7 +65,7 @@ void chDbgPanic3(const char *msg, char * file, int line);
* that's 266Hz camshaft
* for timing measures we need 95760 Hz precision
*/
#define CH_FREQUENCY 100000
#define CH_FREQUENCY 1000
/*===========================================================================*/
/**

2
firmware/emulation/rfi_perftest.cpp
View File

@ -198,7 +198,7 @@ int rtcStartTime;
#include "chrtclib.h"
static void timeInfo(void) {
scheduleMsg(&logger, "chTimeNow as seconds = %d", chTimeNowSeconds());
scheduleMsg(&logger, "chTimeNow as seconds = %d", getTimeNowSeconds());
scheduleMsg(&logger, "hal seconds = %d", halTime.get() / 168000000LL);
int unix = rtcGetTimeUnixSec(&RTCD1) - rtcStartTime;

70
firmware/emulation/wave_analyzer.c
View File

@ -25,8 +25,8 @@
extern engine_configuration_s *engineConfiguration;
static volatile uint32_t ckpPeriod; // different between current crank signal and previous crank signal
static volatile int previousCrankSignalStart = 0;
static volatile uint32_t ckpPeriodUs; // difference between current crank signal and previous crank signal
static volatile uint64_t previousCrankSignalStart = 0;
#define MAX_ICU_COUNT 5
@ -44,36 +44,36 @@ static void ensureInitialized(WaveReader *reader) {
#ifdef EFI_WAVE_ANALYZER
static void waAnaWidthCallback(WaveReader *reader) {
systime_t now = chTimeNow();
uint64_t nowUs = getTimeNowUs();
reader->eventCounter++;
reader->lastActivityTime = now;
reader->lastActivityTimeUs = nowUs;
addWaveChartEvent(reader->name, "up", "");
int width = overflowDiff(now, reader->periodEventTime);
reader->last_wave_low_width = width;
uint64_t width = nowUs - reader->periodEventTimeUs;
reader->last_wave_low_widthUs = width;
reader->signalPeriod = overflowDiff(now, reader->widthEventTime);
reader->widthEventTime = now;
reader->signalPeriodUs = nowUs - reader->widthEventTimeUs;
reader->widthEventTimeUs = nowUs;
}
static void waIcuPeriodCallback(WaveReader *reader) {
systime_t now = chTimeNow();
uint64_t nowUs = getTimeNowUs();
reader->eventCounter++;
reader->lastActivityTime = now;
reader->lastActivityTimeUs = nowUs;
addWaveChartEvent(reader->name, "down", "");
int width = overflowDiff(now, reader->widthEventTime);
reader->last_wave_high_width = width;
uint64_t width = nowUs - reader->widthEventTimeUs;
reader->last_wave_high_widthUs = width;
reader->periodEventTime = now;
reader->periodEventTimeUs = nowUs;
//scheduleSimpleMsg(&irqLogging, "co", reader->chart.counter);
// dbAdd(&wavePeriodTime, now);
int period = ckpPeriod; // local copy of volatile variable
int period = ckpPeriodUs; // local copy of volatile variable
int offset = overflowDiff(now, previousCrankSignalStart);
uint64_t offset = nowUs - previousCrankSignalStart;
if (offset > period / 2) {
/**
@ -81,7 +81,7 @@ static void waIcuPeriodCallback(WaveReader *reader) {
*/
offset -= period;
}
reader->waveOffsetSystimer = offset;
reader->waveOffsetUs = offset;
// we want only the low phase length, so we subsctract high width from period
// processSignal(1, &dataPinReader, last_period - last_adc_response_width);
@ -140,9 +140,9 @@ static void initWave(char *name, int index, ICUDriver *driver, ioportid_t port,
static void onWaveShaftSignal(ShaftEvents ckpSignalType, int index) {
if (index != 0)
return;
systime_t now = chTimeNow();
ckpPeriod = overflowDiff(now, previousCrankSignalStart);
previousCrankSignalStart = now;
uint64_t nowUs = getTimeNowUs();
ckpPeriodUs = nowUs - previousCrankSignalStart;
previousCrankSignalStart = nowUs;
}
static WORKING_AREA(waThreadStack, UTILITY_THREAD_STACK_SIZE);
@ -165,39 +165,39 @@ static msg_t waThread(void *arg) {
int getWaveLowWidth(int index) {
WaveReader *reader = &readers[index];
ensureInitialized(reader);
return reader->last_wave_low_width;
return reader->last_wave_low_widthUs;
}
int getWaveHighWidth(int index) {
float getWaveHighWidthMs(int index) {
WaveReader *reader = &readers[index];
ensureInitialized(reader);
if (overflowDiff(chTimeNow(), reader->lastActivityTime) > 4 * ckpPeriod)
if (getTimeNowUs() - reader->lastActivityTimeUs > 4 * US_PER_SECOND)
return 0; // dwell time has expired
return reader->last_wave_high_width;
return reader->last_wave_high_widthUs / 1000.0;
}
int getWaveOffset(int index) {
uint64_t getWaveOffset(int index) {
WaveReader *reader = &readers[index];
ensureInitialized(reader);
return reader->waveOffsetSystimer;
return reader->waveOffsetUs;
}
int getSignalPeriod(int index) {
float getSignalPeriodMs(int index) {
WaveReader *reader = &readers[index];
ensureInitialized(reader);
return reader->signalPeriod;
return reader->signalPeriodUs / 1000.0;
}
int getWidthEventTime(int index) {
WaveReader *reader = &readers[index];
ensureInitialized(reader);
return reader->widthEventTime;
return reader->widthEventTimeUs;
}
int getPeriodEventTime(int index) {
uint64_t getPeriodEventTime(int index) {
WaveReader *reader = &readers[index];
ensureInitialized(reader);
return reader->periodEventTime;
return reader->periodEventTimeUs;
}
int waveBufferReported = 0;
@ -206,19 +206,19 @@ static void reportWave(Logging *logging, int index) {
// int counter = getEventCounter(index);
// debugInt2(logging, "ev", index, counter);
int dwell = getWaveHighWidth(index);
int period = getSignalPeriod(index);
float dwellMs = getWaveHighWidthMs(index);
float periodMs = getSignalPeriodMs(index);
appendPrintf(logging, "duty%d%s", index, DELIMETER);
appendFloat(logging, 100.0 * dwell / period, 2);
appendFloat(logging, 100.0 * dwellMs / periodMs, 2);
appendPrintf(logging, "%s", DELIMETER);
appendPrintf(logging, "dwell%d%s", index, DELIMETER);
appendFloat(logging, ((float) dwell) / TICKS_IN_MS, 2);
appendFloat(logging, dwellMs, 2);
appendPrintf(logging, "%s", DELIMETER);
appendPrintf(logging, "period%d%s", index, DELIMETER);
appendFloat(logging, ((float) period) / TICKS_IN_MS, 2);
appendFloat(logging, periodMs, 2);
appendPrintf(logging, "%s", DELIMETER);
// int crank = getCrankPeriod();

22
firmware/emulation/wave_analyzer.h
View File

@ -20,15 +20,15 @@ typedef struct {
char *name;
volatile int eventCounter;
volatile systime_t lastActivityTime; // timestamp in systimer ticks
volatile int periodEventTime; // time of signal faoo (systimer ticks)
volatile int widthEventTime; // time of signal rise (systimer ticks)
volatile uint64_t lastActivityTimeUs; // timestamp in microseconds ticks
volatile uint64_t periodEventTimeUs; // time of signal fall in microseconds
volatile uint64_t widthEventTimeUs; // time of signal rise in microseconds
volatile int signalPeriod; // period between two signal rises (systimer ticks)
volatile uint64_t signalPeriodUs; // period between two signal rises in microseconds
volatile int waveOffsetSystimer; // offset from CKP signal in systimer ticks
volatile int last_wave_low_width; // time period in systimer ticks
volatile int last_wave_high_width; // time period in systimer ticks
volatile uint64_t waveOffsetUs; // offset from CKP signal in systimer ticks
volatile uint64_t last_wave_low_widthUs; // time period in systimer ticks
volatile uint64_t last_wave_high_widthUs; // time period in systimer ticks
} WaveReader;
#ifdef __cplusplus
@ -40,16 +40,16 @@ void initWaveAnalyzer(void);
void pokeWaveInfo(void);
void reportWaveInfo(void);
int getWaveLowWidth(int index);
int getWaveHighWidth(int index);
int getWaveOffset(int index);
float getWaveHighWidthMs(int index);
uint64_t getWaveOffset(int index);
int getWaveMode(int index);
int getEventCounter(int index);
int getSignalPeriod(int index);
float getSignalPeriodMs(int index);
int getWidthEventTime(int index);
int getPeriodEventTime(int index);
uint64_t getPeriodEventTime(int index);
//int getCrankStart();
//int getCrankPeriod();