// parameters, outputs, output noise, map func
srcdkf_t *paramsrcdkfInit(int w, int d, int n, SRCDKFMeasurementUpdate_t *map) {
srcdkf_t *f;
f = srcdkfInit(w, d, w, n, (void(*)(float32_t*, float32_t*, float32_t*, float32_t*, float32_t))0);
f->M = d;
f->N = n;
f->map = map;
f->rm = SRCDKF_RM;
matrixInit(&f->KT, d, w);
matrixInit(&f->inovT, 1, d);
matrixInit(&f->rDiag, w, 1);
return f;
}
void matrixISRmode(){
matrixInit();
P1IE |= ALLROWS;
P1IES = ~(ALLROWS); // enables rising edge interrupts
P1IFG = ~(ALLROWS);
P6OUT = ALLCOLS;
_enable_interrupts();
}
void blazar() {
std::string folder{ prepareOutputfolder() };
GlobalConfig = readConfig();
prepareGlobalCfg();
State model(GlobalConfig.get_child("model"));
// model.photon.injection.ps.iterate([&model](const SpaceIterator& i){
// double nph = blackBody(i.val(DIM_E), i.val(DIM_R));
//model.nph.set(i, nph);
//});
// radiativeLosses(model);
injection(model.electron, model);
distribution(model.electron, model);
photonTarget(model.photon, model);
distribution(model.electron, model);
photonDistribution(model.photon, model);
writeAllSpaceParam(getFileName(folder, "electronDist"), model.electron.distribution);
dopplerBoost(getFileName(folder, "SED"), model.photon.distribution);
//writeAllSpaceParam(getFileName(folder, "SED"), model.photon.distribution);
static const int height = GlobalConfig.get<int>("height");
static const int width = GlobalConfig.get<int>("width");
Matrix obs;
matrixInit(obs, height, width, 0.0);
readData("PKS0048-097_lum.txt", obs);
double chi = chiSquareFit(model.photon.distribution, obs, 2);
std::cout << chi;
}
MATRIX *parseFile(char filename[100]){
int rows=0, columns=0, r, c, aux;
FILE *file ;
MATRIX *matrix=NULL;
file = fopen(filename, "r");
fscanf(file, "LINHAS = %i\nCOLUNAS = %i\n", &rows, &columns);
matrix = matrixInit(rows, columns);
for( r=0; r<rows; r++ )
for ( c=0; c<columns; c++ ) {
fscanf(file, "%d", &aux);
matrixInsert(matrix, r, c, aux);
}
return matrix;
}
int main(int argc, char *argv[])
{
int sd;
struct hostent *h;
struct sockaddr_in sa;
FILE *sock = 0;
char *line = 0, *cmd = 0;
size_t linelen = 0;
unsigned int i, j;
size_t dataSize;
struct Matrix matrix;
if (argc > 3 || argc < 2) {
usage(argv[0]);
exit(1);
} else if (argc == 3) {
if (!parseHostPort(argv[1]))
exit(1);
cmd = argv[2];
} else
cmd = argv[1];
if ( !(h = gethostbyname(host)) ) {
herror("gethostbyname");
exit(1);
}
if ( (sd = socket(PF_INET, SOCK_STREAM, 0)) < 0 ) {
perror("socket");
exit(1);
}
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
memcpy(&sa.sin_addr, h->h_addr_list[0], sizeof(struct in_addr));
fprintf(stderr, "Connecting to %s port %hu\n", inet_ntoa(sa.sin_addr), port);
if ( connect(sd, (struct sockaddr *)&sa, sizeof(sa)) ) {
perror("connect");
exit(1);
}
if ( !(sock = fdopen(sd, "r+")) ) {
perror("fdopen");
exit(1);
}
fprintf(stderr, "Connected, sending '%s'\n", cmd);
fprintf(sock, "%s\n", cmd);
fflush(sock);
matrixInit(&matrix);
if ( getline(&line, &linelen, sock) == -1
|| sscanf(line, "MATRIX %u %u", &matrix.m, &matrix.n) != 2) {
if (strstr(line, "ERROR") == line)
fprintf(stderr, "Got ERROR response.. check the command and try again!\n");
else
fprintf(stderr, "Cannot parse matrix dimensions, bailing.\n");
exit(1);
}
fprintf(stderr, "Ok, matrix is %ux%u. Reading matrix data...\n", matrix.m, matrix.n);
matrix.d = calloc(matrix.m*matrix.n, sizeof(double));
if (!matrix.d) {
fprintf(stderr, "Cannot allocate memory.\n");
exit(1);
}
fprintf(sock, "READY\n");
fflush(sock);
dataSize = matrix.m*matrix.n*sizeof(double);
if ( receiveData(matrix.d, dataSize, sock) != (ssize_t)dataSize ) {
fprintf(stderr, "receive error when reading matrix data, bailing\n");
exit(1);
}
fprintf(stderr, "%u bytes read, OK.\n", dataSize);
if ( getline(&line, &linelen, sock) == -1 ) {
fprintf(stderr, "Did not receive any response, exiting.\n");
exit(1);
} else if (strcmp(line, "OK\n")) {
fprintf(stderr, "Got OK.\n");
exit(1);
}
for(i = 0; i < matrix.m; ++i ) {
for (j = 0; j < matrix.n; ++j)
fprintf(stdout, "%lf ", *at(&matrix, i, j));
fprintf(stdout, "\n");
}
fprintf(sock, "EXIT\n");
fflush(sock);
free(line);
free(matrix.d);
shutdown(sd, SHUT_RDWR);
fclose(sock);
return 0;
}
// states, max observations, process noise, max observation noise
srcdkf_t *srcdkfInit(int s, int m, int v, int vMin, int n, SRCDKFTimeUpdate_t *timeUpdate) {
srcdkf_t *f;
int maxN = MAX(v, n);
f = (srcdkf_t *)aqDataCalloc(1, sizeof(srcdkf_t));
f->S = s;
f->V = v;
matrixInit(&f->Sx, s, s);
matrixInit(&f->SxT, s, s);
matrixInit(&f->SxTemp, s, s);
matrixInit(&f->Sv, v, v);
matrixInit(&f->Sn, n, n);
matrixInit(&f->x, s, 1);
matrixInit(&f->Xa, s+maxN, 1+(s+maxN)*2);
matrixInit(&f->qrTempS, s, (s+v)*2);
matrixInit(&f->y, m, 1);
matrixInit(&f->Y, m, 1+(s+n)*2);
matrixInit(&f->qrTempM, m, (s+n)*2);
matrixInit(&f->Sy, m, m);
matrixInit(&f->SyT, m, m);
matrixInit(&f->SyC, m, m);
matrixInit(&f->Pxy, s, m);
matrixInit(&f->C1, m, s);
matrixInit(&f->C1T, s, m);
matrixInit(&f->C2, m, n);
matrixInit(&f->D, m, s+n);
matrixInit(&f->K, s, m);
matrixInit(&f->inov, m, 1);
matrixInit(&f->xUpdate, s, 1);
matrixInit(&f->qrFinal, s, 2*s + 2*n);
matrixInit(&f->Q, s, s+n); // scratch
matrixInit(&f->R, n, n); // scratch
matrixInit(&f->AQ, s, n); // scratch
f->xOut = (float32_t *)aqDataCalloc((uint16_t)s, sizeof(float32_t));
f->xNoise = (float32_t *)aqDataCalloc(maxN, sizeof(float32_t));
f->xIn = (float32_t *)aqDataCalloc((uint16_t)s, sizeof(float32_t));
f->h = (float32_t)SRCDKF_H;
f->hh = f->h*f->h;
// f->w0m = (f->hh - (float32_t)s) / f->hh; // calculated in process
f->wim = 1.0f / (2.0f * f->hh);
f->wic1 = (float32_t)aq_sqrtf(1.0f / (4.0f * f->hh));
f->wic2 = (float32_t)aq_sqrtf((f->hh - 1.0f) / (4.0f * f->hh*f->hh));
f->timeUpdate = timeUpdate;
return f;
}
int main(void)
{
int8_t encCnt = 0;
uint8_t cmd = CMD_END;
static uint8_t dispPrev = MODE_STANDBY;
rcInit();
sndInit();
matrixInit();
sei();
_delay_ms(100);
powerOff();
while(1) {
encCnt = getEncoder();
cmd = getCmdBuf();
/* If no command from buttons, try remote control */
if (cmd == CMD_END)
cmd = getRcBuf();
/* Don't handle commands in standby mode except some */
if (dispMode == MODE_STANDBY) {
encCnt = 0;
if (cmd != CMD_RC_STBY && cmd != CMD_BTN_1 && cmd != CMD_BTN_1_2_LONG)
cmd = CMD_END;
}
/* Don't handle buttons in learn mode except some */
if (dispMode == MODE_LEARN) {
if (encCnt || cmd != CMD_END)
displayTime = TIMEOUT_LEARN;
if (cmd != CMD_BTN_1_LONG && cmd != CMD_BTN_3)
cmd = CMD_END;
}
/* Handle command */
switch (cmd) {
case CMD_RC_STBY:
case CMD_BTN_1:
if (dispMode == MODE_STANDBY)
powerOn();
else
powerOff();
break;
case CMD_RC_MUTE:
case CMD_BTN_2:
if (dispMode == MODE_TIME_EDIT) {
rtcNextEditParam();
displayTime = TIMEOUT_TIME_EDIT;
} else {
if (aproc.mute) {
sndSetMute(0);
dispMode = MODE_SND_VOLUME;
} else {
sndSetMute(1);
dispMode = MODE_MUTE;
}
displayTime = TIMEOUT_AUDIO;
}
break;
case CMD_RC_MENU:
case CMD_BTN_3:
if (dispMode == MODE_LEARN) {
nextRcCmd();
} else {
sndNextParam(&dispMode);
displayTime = TIMEOUT_AUDIO;
}
break;
case CMD_RC_RED:
case CMD_RC_GREEN:
case CMD_RC_YELLOW:
case CMD_RC_BLUE:
sndSetInput(cmd - CMD_RC_RED);
dispMode = MODE_SND_GAIN0 + (cmd - CMD_RC_RED);
displayTime = TIMEOUT_AUDIO;
break;
case CMD_BTN_1_LONG:
switch (dispMode) {
case MODE_STANDBY:
case MODE_LEARN:
powerOff();
break;
default:
dispMode = MODE_BRIGHTNESS;
displayTime = TIMEOUT_BR;
break;
}
break;
case CMD_BTN_2_LONG:
switch (dispMode) {
case MODE_TIME_EDIT:
dispMode = MODE_TIME;
rtc.etm = RTC_NOEDIT;
break;
default:
dispMode = MODE_TIME_EDIT;
rtc.etm = RTC_HOUR;
displayTime = TIMEOUT_TIME_EDIT;
break;
}
break;
case CMD_RC_NEXT:
case CMD_BTN_3_LONG:
if (dispMode >= MODE_SND_GAIN0 && dispMode < MODE_SND_END)
aproc.input++;
sndSetInput(aproc.input);
dispMode = MODE_SND_GAIN0 + aproc.input;
displayTime = TIMEOUT_AUDIO;
break;
case CMD_BTN_1_2_LONG:
if (dispMode == MODE_STANDBY)
dispMode = MODE_LEARN;
switchTestMode(CMD_RC_STBY);
displayTime = TIMEOUT_LEARN;
break;
}
/* Emulate RC VOL_UP/VOL_DOWN as encoder actions */
if (cmd == CMD_RC_VOL_UP)
encCnt++;
if (cmd == CMD_RC_VOL_DOWN)
encCnt--;
/* Handle encoder */
if (encCnt) {
switch (dispMode) {
case MODE_STANDBY:
case MODE_LEARN:
break;
case MODE_TIME_EDIT:
displayTime = TIMEOUT_TIME_EDIT;
rtcChangeTime(encCnt);
break;
case MODE_BRIGHTNESS:
changeBrWork(encCnt);
displayTime = TIMEOUT_BR;
break;
case MODE_MUTE:
case MODE_LOUDNESS:
case MODE_TIME:
dispMode = MODE_SND_VOLUME;
default:
sndSetMute(0);
sndChangeParam(dispMode, encCnt);
displayTime = TIMEOUT_AUDIO;
break;
}
}
/* Exid to default mode if timer expired */
if (displayTime == 0) {
if (dispMode == MODE_LEARN || dispMode == MODE_STANDBY) {
dispMode = MODE_STANDBY;
} else {
rtc.etm = RTC_NOEDIT;
if (aproc.mute)
dispMode = MODE_MUTE;
else
dispMode = MODE_TIME;
}
}
/* Show things */
switch (dispMode) {
case MODE_STANDBY:
showStby();
break;
case MODE_MUTE:
showMute();
break;
case MODE_LOUDNESS:
showLoudness();
break;
case MODE_LEARN:
showLearn();
break;
case MODE_TIME:
case MODE_TIME_EDIT:
showTime();
break;
case MODE_BRIGHTNESS:
showBrWork();
break;
default:
showSndParam(dispMode, ICON_NATIVE);
break;
}
if (dispMode == dispPrev)
updateScreen(EFFECT_NONE, dispMode);
else
updateScreen(EFFECT_SPLASH, dispMode);
dispPrev = dispMode;
}
return 0;
}
int main(void)
{
matrixInit();
sei();
matrixSetBr(4);
matrixSetFont(font_matrix_16, 1);
matrixLoadOutString("Large ");
matrixShow(ROW_BOTH, EFFECT_SCROLL_UP);
DDR(BUZZER) |= BUZZER_LINE;
PORT(BUZZER) &= ~BUZZER_LINE;
_delay_ms(50);
PORT(BUZZER) |= BUZZER_LINE;
matrixClear(ROW_BOTH, EFFECT_NONE);
while (1) {
rtcReadTime();
matrixSetCol(0, ROW_BOTH);
matrixSetFont(font_matrix_16, 1);
matrixLoadOutString(mkNumberString(rtc.hour, 2, 0, '0'));
matrixLoadOutString(":");
matrixLoadOutString(mkNumberString(rtc.min, 2, 0, '0'));
matrixSetFont(font_matrix_08, 1);
matrixSetCol(55, ROW_TOP);
matrixLoadOutString(mkNumberString(rtc.sec, 2, 0, '0'));
matrixSetCol(55, ROW_BOTTOM);
matrixLoadOutString(mkNumberString(rtc.date, 2, 0, '0'));
matrixShow(ROW_BOTH, EFFECT_NONE);
}
while (1) {
matrixSetFont(font_matrix_08, 1);
matrixClear(ROW_BOTH, EFFECT_SCROLL_DOWN);
matrixSetCol(0, ROW_TOP);
matrixLoadOutString("Top");
matrixSetCol(9, ROW_BOTTOM);
matrixLoadOutString("Low");
matrixSetFont(font_matrix_16, 1);
matrixSetCol(30, ROW_BOTH);
matrixLoadOutString("Big");
matrixShow(ROW_BOTH, EFFECT_SCROLL_UP);
_delay_ms(1000);
matrixSetFont(font_matrix_16, 1);
matrixLoadScrollString(" Scroll");
matrixLoadScrollString(" large font");
matrixScroll(SCROLL_START, ROW_BOTH);
matrixSetCol(0, ROW_TOP);
matrixLoadOutString("Large ");
_delay_ms(3000);
matrixShow(ROW_BOTH, EFFECT_SCROLL_UP);
_delay_ms(1000);
matrixClear(ROW_BOTH, EFFECT_SCROLL_DOWN);
matrixSetFont(font_matrix_08, 1);
matrixLoadScrollString("Scroll");
matrixLoadScrollString(" top line");
matrixScroll(SCROLL_START, ROW_TOP);
matrixSetCol(0, ROW_BOTTOM);
matrixLoadOutString("Small");
matrixLoadOutString(" font");
_delay_ms(1000);
matrixShow(ROW_BOTTOM, EFFECT_SCROLL_UP);
_delay_ms(1000);
matrixSetFont(font_matrix_08, 1);
matrixLoadScrollString("Scroll");
matrixLoadScrollString(" bottom line");
matrixScroll(SCROLL_START, ROW_BOTTOM);
matrixSetCol(0, ROW_TOP);
matrixLoadOutString("Small");
matrixLoadOutString(" font");
_delay_ms(1000);
matrixShow(ROW_TOP, EFFECT_SCROLL_DOWN);
_delay_ms(1000);
}
return 0;
}
