struct addrspace *
as_create(void)
{
struct addrspace *as;
as = kmalloc(sizeof(struct addrspace));
if (as == NULL) {
return NULL;
}
as->as_pgtbl = pt_create();
if (as->as_pgtbl == NULL) {
kfree(as);
return NULL;
}
// Start with empty segments
for (int i = 0; i < NSEGS; i++)
seg_zero(&as->as_segs[i]);
// set up the stack and heap to be writeable
seg_init(&as->AS_STACK, 0, 0, true);
seg_init(&as->AS_HEAP, 0, 0, true);
as->as_loading = false;
as->as_id = 0;
return as;
}
proc_t *proc_create(void)
{
proc_t *proc = malloc(sizeof(*proc));
if (!proc)
return 0;
proc->pml4_table = pmm_alloc();
if (!proc->pml4_table)
{
free(proc);
return 0;
}
if (!vmm_init_pml4(proc->pml4_table))
{
pmm_free(proc->pml4_table);
free(proc);
return 0;
}
proc->vmm_lock = SPIN_UNLOCKED;
if (!seg_init(&proc->segments))
{
pmm_free(proc->pml4_table);
free(proc);
return 0;
}
proc->state = PROC_RUNNING;
list_init(&proc->thread_list);
return proc;
}
void init_seg(){
seg_init();
idt_init();
zero_mem(&interrupt_handlers, sizeof(w_isr) * 256);
//tss_flush();
}
/*
* Set up a segment at virtual address VADDR of size MEMSIZE. The
* segment in memory extends from VADDR up to (but not including)
* VADDR+MEMSIZE.
*
* The READABLE, WRITEABLE, and EXECUTABLE flags are set if read,
* write, or execute permission should be set on the segment. At the
* moment, these are ignored. When you write the VM system, you may
* want to implement them.
*/
int
as_define_region(struct addrspace *as, vaddr_t vaddr, size_t sz,
int readable, int writeable, int executable)
{
// unused
(void)executable;
(void)readable;
// Find an empty region and fill it
// Temporarily allow writes until load is complete
for (int i = 0; i < NSEGS; i++) {
if (seg_available(&as->as_segs[i])) {
seg_init(&as->as_segs[i], vaddr, sz, writeable);
// Update base of the heap
vaddr_t seg_top_aligned = (vaddr + sz + PAGE_SIZE - 1) & PAGE_FRAME;
if (as->AS_HEAP.seg_base < seg_top_aligned)
as->AS_HEAP.seg_base = seg_top_aligned;
return 0;
}
}
return ENOMEM;
}
/*----------------------------------------------------------------------------*/
void init_disp(void)
{
init_disp_buf();
seg_init();
com_init();
LCD_BACKLIGHT_INIT();
LCD_BACKLIGHT_ON();
}
int
as_define_stack(struct addrspace *as, vaddr_t *stackptr)
{
vaddr_t stackbase = USERSTACK - PAGE_SIZE * STACK_NPAGES;
// check for overlap with the heap
vaddr_t heaptop = as->AS_HEAP.seg_base + as->AS_HEAP.seg_size;
if (stackbase < heaptop)
return ENOMEM;
// seg up stack segment
seg_init(&as->AS_STACK, stackbase, STACK_NPAGES * PAGE_SIZE, true);
// Initial user-level stack pointer
*stackptr = USERSTACK;
return 0;
}
int main(void)
{
uint8_t delay1 = 0, delay2 = 0, delay3 = 0;
seg_init();
mat_init();
uart_init();
sei();
uart_puts("\n\n");
uart_puts("/o/i/booting\r\n");
while(1)
{
for(uint8_t i=0; i<3;i++) uart_process();
delay2++;
if(delay2 == 200){
delay2 = 0;
mat_check();
delay1++;
if(delay1 == 200){
delay1 = 0;
mat_debug();
test();
uart_puts("d\r\n");
if(delay3 == 10){
delay3 = 0;
uart_puts("\n");
}
connect(); //checks hastoconnect variable
}
}
_delay_us(5);
}
}
void io_init()
{
seg_init();
mdelay(200);
}
// Function that reads from a MiniSEED binary file from a char buffer and
// returns a LinkedIDList.
LinkedIDList *
readMSEEDBuffer (char *mseed, int buflen, Selections *selections, flag
unpack_data, int reclen, flag verbose, flag details,
int header_byteorder, long (*allocData) (int, char),
void (*diag_print) (char*), void (*log_print) (char*))
{
int retcode = 0;
int retval = 0;
flag swapflag = 0;
// current offset of mseed char pointer
int offset = 0;
// Unpack without reading the data first
flag dataflag = 0;
// the timing_qual of BLK 1001
uint8_t timing_qual = 0xFF;
// the calibration type, availability of BLK 300, 310, 320, 390, 395
int8_t calibration_type = -1;
// Init all the pointers to NULL. Most compilers should do this anyway.
LinkedIDList * idListHead = NULL;
LinkedIDList * idListCurrent = NULL;
LinkedIDList * idListLast = NULL;
MSRecord *msr = NULL;
ContinuousSegment * segmentCurrent = NULL;
hptime_t lastgap = 0;
hptime_t hptimetol = 0;
hptime_t nhptimetol = 0;
long data_offset;
LinkedRecordList *recordHead = NULL;
LinkedRecordList *recordPrevious = NULL;
LinkedRecordList *recordCurrent = NULL;
int datasize;
int record_count = 0;
// A negative verbosity suppressed as much as possible.
if (verbose < 0) {
ms_loginit(&empty_print, NULL, &empty_print, NULL);
}
else {
ms_loginit(log_print, "INFO: ", diag_print, "ERROR: ");
}
if (header_byteorder >= 0) {
// Enforce little endian.
if (header_byteorder == 0) {
MS_UNPACKHEADERBYTEORDER(0);
}
// Enforce big endian.
else {
MS_UNPACKHEADERBYTEORDER(1);
}
}
else {
MS_UNPACKHEADERBYTEORDER(-1);
}
//
// Read all records and save them in a linked list.
//
while (offset < buflen) {
msr = msr_init(NULL);
if ( msr == NULL ) {
ms_log (2, "readMSEEDBuffer(): Error initializing msr\n");
return NULL;
}
if (verbose > 1) {
ms_log(0, "readMSEEDBuffer(): calling msr_parse with "
"mseed+offset=%d+%d, buflen=%d, reclen=%d, dataflag=%d, verbose=%d\n",
mseed, offset, buflen, reclen, dataflag, verbose);
}
// If the record length is given, make sure at least that amount of data is available.
if (reclen != -1) {
if (offset + reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
}
// Otherwise assume the smallest possible record length and assure that enough
// data is present.
else {
if (offset + 256 > buflen) {
ms_log(1, "readMSEEDBuffer(): Last record only has %i byte(s) which "
"is not enough to constitute a full SEED record. Corrupt data? "
"Record will be skipped.\n", buflen - offset);
msr_free(&msr);
break;
}
}
// Pass (buflen - offset) because msr_parse() expects only a single record. This
// way libmseed can take care to not overstep bounds.
retcode = msr_parse ( (mseed+offset), buflen - offset, &msr, reclen, dataflag, verbose);
if (retcode != MS_NOERROR) {
switch ( retcode ) {
case MS_ENDOFFILE:
ms_log(1, "readMSEEDBuffer(): Unexpected end of file when "
"parsing record starting at offset %d. The rest "
"of the file will not be read.\n", offset);
break;
case MS_GENERROR:
ms_log(1, "readMSEEDBuffer(): Generic error when parsing "
"record starting at offset %d. The rest of the "
"file will not be read.\n", offset);
break;
case MS_NOTSEED:
ms_log(1, "readMSEEDBuffer(): Record starting at offset "
"%d is not valid SEED. The rest of the file "
"will not be read.\n", offset);
break;
case MS_WRONGLENGTH:
ms_log(1, "readMSEEDBuffer(): Length of data read was not "
"correct when parsing record starting at "
"offset %d. The rest of the file will not be "
"read.\n", offset);
break;
case MS_OUTOFRANGE:
ms_log(1, "readMSEEDBuffer(): SEED record length out of "
"range for record starting at offset %d. The "
"rest of the file will not be read.\n", offset);
break;
case MS_UNKNOWNFORMAT:
ms_log(1, "readMSEEDBuffer(): Unknown data encoding "
"format for record starting at offset %d. The "
"rest of the file will not be read.\n", offset);
break;
case MS_STBADCOMPFLAG:
ms_log(1, "readMSEEDBuffer(): Invalid STEIM compression "
"flag(s) in record starting at offset %d. The "
"rest of the file will not be read.\n", offset);
break;
default:
ms_log(1, "readMSEEDBuffer(): Unknown error '%d' in "
"record starting at offset %d. The rest of the "
"file will not be read.\n", retcode, offset);
break;
}
msr_free(&msr);
break;
}
if (offset + msr->reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last msr->reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
// Test against selections if supplied
if ( selections ) {
char srcname[50];
hptime_t endtime;
msr_srcname (msr, srcname, 1);
endtime = msr_endtime (msr);
if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) {
// Add the record length for the next iteration
offset += msr->reclen;
// Free record.
msr_free(&msr);
continue;
}
}
record_count += 1;
recordCurrent = lrl_init ();
// Append to linked record list if one exists.
if ( recordHead != NULL ) {
recordPrevious->next = recordCurrent;
recordCurrent->previous = recordPrevious;
recordCurrent->next = NULL;
recordPrevious = recordCurrent;
}
// Otherwise create a new one.
else {
recordHead = recordCurrent;
recordCurrent->previous = NULL;
recordPrevious = recordCurrent;
}
recordCurrent->record = msr;
// Determine the byte order swapflag only for the very first record.
// The byte order should not change within the file.
// XXX: Maybe check for every record?
if (swapflag <= 0) {
// Returns 0 if the host is little endian, otherwise 1.
flag bigendianhost = ms_bigendianhost();
// Set the swapbyteflag if it is needed.
if ( msr->Blkt1000 != 0) {
/* If BE host and LE data need swapping */
if ( bigendianhost && msr->byteorder == 0 ) {
swapflag = 1;
}
/* If LE host and BE data (or bad byte order value) need swapping */
if ( !bigendianhost && msr->byteorder > 0 ) {
swapflag = 1;
}
}
}
// Actually unpack the data if the flag is not set.
if (unpack_data != 0) {
retval = msr_unpack_data (msr, swapflag, verbose);
}
if ( retval > 0 ) {
msr->numsamples = retval;
}
// Add the record length for the next iteration
offset += msr->reclen;
}
// Return empty id list if no records could be found.
if (record_count == 0) {
idListHead = lil_init();
return idListHead;
}
// All records that match the selection are now stored in a LinkedRecordList
// that starts at recordHead. The next step is to sort them by matching ids
// and then by time.
recordCurrent = recordHead;
while (recordCurrent != NULL) {
// Check if the ID of the record is already available and if not create a
// new one.
// Start with the last id as it is most likely to be the correct one.
idListCurrent = idListLast;
while (idListCurrent != NULL) {
if (strcmp(idListCurrent->network, recordCurrent->record->network) == 0 &&
strcmp(idListCurrent->station, recordCurrent->record->station) == 0 &&
strcmp(idListCurrent->location, recordCurrent->record->location) == 0 &&
strcmp(idListCurrent->channel, recordCurrent->record->channel) == 0 &&
idListCurrent->dataquality == recordCurrent->record->dataquality) {
break;
}
else {
idListCurrent = idListCurrent->previous;
}
}
// Create a new id list if one is needed.
if (idListCurrent == NULL) {
idListCurrent = lil_init();
idListCurrent->previous = idListLast;
if (idListLast != NULL) {
idListLast->next = idListCurrent;
}
idListLast = idListCurrent;
if (idListHead == NULL) {
idListHead = idListCurrent;
}
// Set the IdList attributes.
strcpy(idListCurrent->network, recordCurrent->record->network);
strcpy(idListCurrent->station, recordCurrent->record->station);
strcpy(idListCurrent->location, recordCurrent->record->location);
strcpy(idListCurrent->channel, recordCurrent->record->channel);
idListCurrent->dataquality = recordCurrent->record->dataquality;
}
// Now check if the current record fits exactly to the end of the last
// segment of the current id. If not create a new segment. Therefore
// if records with the same id are in wrong order a new segment will be
// created. This is on purpose.
segmentCurrent = idListCurrent->lastSegment;
if (segmentCurrent != NULL) {
hptimetol = (hptime_t) (0.5 * segmentCurrent->hpdelta);
nhptimetol = ( hptimetol ) ? -hptimetol : 0;
lastgap = recordCurrent->record->starttime - segmentCurrent->endtime - segmentCurrent->hpdelta;
}
if (details == 1) {
/* extract information on calibration BLKs */
calibration_type = -1;
if (recordCurrent->record->blkts) {
BlktLink *cur_blkt = recordCurrent->record->blkts;
while (cur_blkt) {
switch (cur_blkt->blkt_type) {
case 300:
calibration_type = 1;
break;
case 310:
calibration_type = 2;
break;
case 320:
calibration_type = 3;
break;
case 390:
calibration_type = 4;
break;
case 395:
calibration_type = -2;
break;
default:
break;
}
cur_blkt = cur_blkt->next;
}
}
/* extract information based on timing quality */
timing_qual = 0xFF;
if (recordCurrent->record->Blkt1001 != 0) {
timing_qual = recordCurrent->record->Blkt1001->timing_qual;
}
}
if ( segmentCurrent != NULL &&
segmentCurrent->sampletype == recordCurrent->record->sampletype &&
// Test the default sample rate tolerance: abs(1-sr1/sr2) < 0.0001
MS_ISRATETOLERABLE (segmentCurrent->samprate, recordCurrent->record->samprate) &&
// Check if the times are within the time tolerance
lastgap <= hptimetol && lastgap >= nhptimetol &&
segmentCurrent->timing_qual == timing_qual &&
segmentCurrent->calibration_type == calibration_type) {
recordCurrent->previous = segmentCurrent->lastRecord;
segmentCurrent->lastRecord = segmentCurrent->lastRecord->next = recordCurrent;
segmentCurrent->samplecnt += recordCurrent->record->samplecnt;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
}
// Otherwise create a new segment and add the current record.
else {
segmentCurrent = seg_init();
segmentCurrent->previous = idListCurrent->lastSegment;
if (idListCurrent->lastSegment != NULL) {
idListCurrent->lastSegment->next = segmentCurrent;
}
else {
idListCurrent->firstSegment = segmentCurrent;
}
idListCurrent->lastSegment = segmentCurrent;
segmentCurrent->starttime = recordCurrent->record->starttime;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
segmentCurrent->samprate = recordCurrent->record->samprate;
segmentCurrent->sampletype = recordCurrent->record->sampletype;
segmentCurrent->samplecnt = recordCurrent->record->samplecnt;
// Calculate high-precision sample period
segmentCurrent->hpdelta = (hptime_t) (( recordCurrent->record->samprate ) ?
(HPTMODULUS / recordCurrent->record->samprate) : 0.0);
segmentCurrent->timing_qual = timing_qual;
segmentCurrent->calibration_type = calibration_type;
segmentCurrent->firstRecord = segmentCurrent->lastRecord = recordCurrent;
recordCurrent->previous = NULL;
}
recordPrevious = recordCurrent->next;
recordCurrent->next = NULL;
recordCurrent = recordPrevious;
}
// Now loop over all segments, combine the records and free the msr
// structures.
idListCurrent = idListHead;
while (idListCurrent != NULL)
{
segmentCurrent = idListCurrent->firstSegment;
while (segmentCurrent != NULL) {
if (segmentCurrent->datasamples) {
free(segmentCurrent->datasamples);
}
// Allocate data via a callback function.
if (unpack_data != 0) {
segmentCurrent->datasamples = (void *) allocData(segmentCurrent->samplecnt, segmentCurrent->sampletype);
}
// Loop over all records, write the data to the buffer and free the msr structures.
recordCurrent = segmentCurrent->firstRecord;
data_offset = (long)(segmentCurrent->datasamples);
while (recordCurrent != NULL) {
datasize = recordCurrent->record->samplecnt * ms_samplesize(recordCurrent->record->sampletype);
memcpy((void *)data_offset, recordCurrent->record->datasamples, datasize);
// Free the record.
msr_free(&(recordCurrent->record));
// Increase the data_offset and the record.
data_offset += (long)datasize;
recordCurrent = recordCurrent->next;
}
segmentCurrent = segmentCurrent->next;
}
idListCurrent = idListCurrent->next;
}
return idListHead;
}
// Function that reads from a MiniSEED binary file from a char buffer and
// returns a LinkedIDList.
LinkedIDList *
readMSEEDBuffer (char *mseed, int buflen, Selections *selections, flag
unpack_data, int reclen, flag verbose, flag details,
int header_byteorder, long long (*allocData) (int, char),
void (*diag_print) (char*), void (*log_print) (char*))
{
int retcode = 0;
int retval = 0;
flag swapflag = 0;
flag bigendianhost = ms_bigendianhost();
// current offset of mseed char pointer
int offset = 0;
// Unpack without reading the data first
flag dataflag = 0;
// the timing_qual of BLK 1001
uint8_t timing_qual = 0xFF;
// the calibration type, availability of BLK 300, 310, 320, 390, 395
int8_t calibration_type = -1;
// Init all the pointers to NULL. Most compilers should do this anyway.
LinkedIDList * idListHead = NULL;
LinkedIDList * idListCurrent = NULL;
LinkedIDList * idListLast = NULL;
MSRecord *msr = NULL;
ContinuousSegment * segmentCurrent = NULL;
hptime_t lastgap = 0;
hptime_t hptimetol = 0;
hptime_t nhptimetol = 0;
long long data_offset;
LinkedRecordList *recordHead = NULL;
LinkedRecordList *recordPrevious = NULL;
LinkedRecordList *recordCurrent = NULL;
int datasize;
int record_count = 0;
// A negative verbosity suppresses as much as possible.
if (verbose < 0) {
ms_loginit(&empty_print, NULL, &empty_print, NULL);
}
else {
ms_loginit(log_print, "INFO: ", diag_print, "ERROR: ");
}
if (header_byteorder >= 0) {
// Enforce little endian.
if (header_byteorder == 0) {
MS_UNPACKHEADERBYTEORDER(0);
}
// Enforce big endian.
else {
MS_UNPACKHEADERBYTEORDER(1);
}
}
else {
MS_UNPACKHEADERBYTEORDER(-1);
}
// Read all records and save them in a linked list.
while (offset < buflen) {
msr = msr_init(NULL);
if ( msr == NULL ) {
ms_log (2, "readMSEEDBuffer(): Error initializing msr\n");
return NULL;
}
if (verbose > 1) {
ms_log(0, "readMSEEDBuffer(): calling msr_parse with "
"mseed+offset=%d+%d, buflen=%d, reclen=%d, dataflag=%d, verbose=%d\n",
mseed, offset, buflen, reclen, dataflag, verbose);
}
// If the record length is given, make sure at least that amount of data is available.
if (reclen != -1) {
if (offset + reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
}
// Otherwise assume the smallest possible record length and assure that enough
// data is present.
else {
if (offset + MINRECLEN > buflen) {
ms_log(1, "readMSEEDBuffer(): Last record only has %i byte(s) which "
"is not enough to constitute a full SEED record. Corrupt data? "
"Record will be skipped.\n", buflen - offset);
msr_free(&msr);
break;
}
}
// Skip empty or noise records.
if (OBSPY_ISVALIDBLANK(mseed + offset)) {
offset += MINRECLEN;
continue;
}
// Pass (buflen - offset) because msr_parse() expects only a single record. This
// way libmseed can take care to not overstep bounds.
// Return values:
// 0 : Success, populates the supplied MSRecord.
// >0 : Data record detected but not enough data is present, the
// return value is a hint of how many more bytes are needed.
// <0 : libmseed error code (listed in libmseed.h) is returned.
retcode = msr_parse ((mseed+offset), buflen - offset, &msr, reclen, dataflag, verbose);
// Handle error.
if (retcode < 0) {
log_error(retcode, offset);
msr_free(&msr);
break;
}
// msr_parse() returns > 0 if a data record has been detected but the buffer either has not enough
// data (this cannot happen with ObsPy's logic) or the last record has no Blockette 1000 and it cannot
// determine the record length because there is no next record (this can happen in ObsPy) - handle that
// case by just calling msr_parse() with an explicit record length set.
else if ( retcode > 0 && retcode < (buflen - offset)) {
// Check if the remaining bytes can exactly make up a record length.
int r_bytes = buflen - offset;
float exp = log10((float)r_bytes) / log10(2.0);
if ((fmodf(exp, 1.0) < 0.0000001) && ((int)roundf_(exp) >= 7) && ((int)roundf_(exp) <= 256)) {
retcode = msr_parse((mseed + offset), buflen - offset, &msr, r_bytes, dataflag, verbose);
if ( retcode != 0 ) {
log_error(retcode, offset);
msr_free(&msr);
break;
}
}
else {
msr_free(&msr);
break;
}
}
if (offset + msr->reclen > buflen) {
ms_log(1, "readMSEEDBuffer(): Last msr->reclen exceeds buflen, skipping.\n");
msr_free(&msr);
break;
}
// Test against selections if supplied
if ( selections ) {
char srcname[50];
hptime_t endtime;
msr_srcname (msr, srcname, 1);
endtime = msr_endtime (msr);
if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) {
// Add the record length for the next iteration
offset += msr->reclen;
// Free record.
msr_free(&msr);
continue;
}
}
record_count += 1;
recordCurrent = lrl_init ();
// Append to linked record list if one exists.
if ( recordHead != NULL ) {
recordPrevious->next = recordCurrent;
recordCurrent->previous = recordPrevious;
recordCurrent->next = NULL;
recordPrevious = recordCurrent;
}
// Otherwise create a new one.
else {
recordHead = recordCurrent;
recordCurrent->previous = NULL;
recordPrevious = recordCurrent;
}
recordCurrent->record = msr;
// Figure out if the byte-order of the data has to be swapped.
swapflag = 0;
// If blockette 1000 is present, use it.
if ( msr->Blkt1000 != 0) {
/* If BE host and LE data need swapping */
if ( bigendianhost && msr->byteorder == 0 ) {
swapflag = 1;
}
/* If LE host and BE data (or bad byte order value) need swapping */
if ( !bigendianhost && msr->byteorder > 0 ) {
swapflag = 1;
}
}
// Otherwise assume the data has the same byte order as the header.
// This needs to be done on the raw header bytes as libmseed only returns
// header fields in the native byte order.
else {
unsigned char* _t = (unsigned char*)mseed + offset + 20;
unsigned int year = _t[0] | _t[1] << 8;
unsigned int day = _t[2] | _t[3] << 8;
// Swap data if header needs to be swapped.
if (!MS_ISVALIDYEARDAY(year, day)) {
swapflag = 1;
}
}
// Actually unpack the data if the flag is not set and if the data
// offset is valid.
if ((unpack_data != 0) && (msr->fsdh->data_offset >= 48) &&
(msr->fsdh->data_offset < msr->reclen) &&
(msr->samplecnt > 0)) {
retval = msr_unpack_data (msr, swapflag, verbose);
}
if ( retval > 0 ) {
msr->numsamples = retval;
}
if ( msr->fsdh->start_time.fract > 9999 ) {
ms_log(1, "readMSEEDBuffer(): Record with offset=%d has a "
"fractional second (.0001 seconds) of %d. This is not "
"strictly valid but will be interpreted as one or more "
"additional seconds.",
offset, msr->fsdh->start_time.fract);
}
// Add the record length for the next iteration
offset += msr->reclen;
}
// Return empty id list if no records could be found.
if (record_count == 0) {
idListHead = lil_init();
return idListHead;
}
// All records that match the selection are now stored in a LinkedRecordList
// that starts at recordHead. The next step is to sort them by matching ids
// and then by time.
recordCurrent = recordHead;
while (recordCurrent != NULL) {
// Check if the ID of the record is already available and if not create a
// new one.
// Start with the last id as it is most likely to be the correct one.
idListCurrent = idListLast;
while (idListCurrent != NULL) {
if (strcmp(idListCurrent->network, recordCurrent->record->network) == 0 &&
strcmp(idListCurrent->station, recordCurrent->record->station) == 0 &&
strcmp(idListCurrent->location, recordCurrent->record->location) == 0 &&
strcmp(idListCurrent->channel, recordCurrent->record->channel) == 0 &&
idListCurrent->dataquality == recordCurrent->record->dataquality) {
break;
}
else {
idListCurrent = idListCurrent->previous;
}
}
// Create a new id list if one is needed.
if (idListCurrent == NULL) {
idListCurrent = lil_init();
idListCurrent->previous = idListLast;
if (idListLast != NULL) {
idListLast->next = idListCurrent;
}
idListLast = idListCurrent;
if (idListHead == NULL) {
idListHead = idListCurrent;
}
// Set the IdList attributes.
strcpy(idListCurrent->network, recordCurrent->record->network);
strcpy(idListCurrent->station, recordCurrent->record->station);
strcpy(idListCurrent->location, recordCurrent->record->location);
strcpy(idListCurrent->channel, recordCurrent->record->channel);
idListCurrent->dataquality = recordCurrent->record->dataquality;
}
// Now check if the current record fits exactly to the end of the last
// segment of the current id. If not create a new segment. Therefore
// if records with the same id are in wrong order a new segment will be
// created. This is on purpose.
segmentCurrent = idListCurrent->lastSegment;
if (segmentCurrent != NULL) {
hptimetol = (hptime_t) (0.5 * segmentCurrent->hpdelta);
nhptimetol = ( hptimetol ) ? -hptimetol : 0;
lastgap = recordCurrent->record->starttime - segmentCurrent->endtime - segmentCurrent->hpdelta;
}
if (details == 1) {
/* extract information on calibration BLKs */
calibration_type = -1;
if (recordCurrent->record->blkts) {
BlktLink *cur_blkt = recordCurrent->record->blkts;
while (cur_blkt) {
switch (cur_blkt->blkt_type) {
case 300:
calibration_type = 1;
break;
case 310:
calibration_type = 2;
break;
case 320:
calibration_type = 3;
break;
case 390:
calibration_type = 4;
break;
case 395:
calibration_type = -2;
break;
default:
break;
}
cur_blkt = cur_blkt->next;
}
}
/* extract information based on timing quality */
timing_qual = 0xFF;
if (recordCurrent->record->Blkt1001 != 0) {
timing_qual = recordCurrent->record->Blkt1001->timing_qual;
}
}
if ( segmentCurrent != NULL &&
// This is important for zero data record coupled with not unpacking
// the data. It needs to be split in two places: Before the zero data
// record and after it.
recordCurrent->record->samplecnt > 0 && segmentCurrent->samplecnt > 0 &&
segmentCurrent->sampletype == recordCurrent->record->sampletype &&
// Test the default sample rate tolerance: abs(1-sr1/sr2) < 0.0001
MS_ISRATETOLERABLE (segmentCurrent->samprate, recordCurrent->record->samprate) &&
// Check if the times are within the time tolerance
lastgap <= hptimetol && lastgap >= nhptimetol &&
segmentCurrent->timing_qual == timing_qual &&
segmentCurrent->calibration_type == calibration_type) {
recordCurrent->previous = segmentCurrent->lastRecord;
segmentCurrent->lastRecord = segmentCurrent->lastRecord->next = recordCurrent;
segmentCurrent->samplecnt += recordCurrent->record->samplecnt;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
}
// Otherwise create a new segment and add the current record.
else {
segmentCurrent = seg_init();
segmentCurrent->previous = idListCurrent->lastSegment;
if (idListCurrent->lastSegment != NULL) {
idListCurrent->lastSegment->next = segmentCurrent;
}
else {
idListCurrent->firstSegment = segmentCurrent;
}
idListCurrent->lastSegment = segmentCurrent;
segmentCurrent->starttime = recordCurrent->record->starttime;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
segmentCurrent->samprate = recordCurrent->record->samprate;
segmentCurrent->sampletype = recordCurrent->record->sampletype;
segmentCurrent->samplecnt = recordCurrent->record->samplecnt;
// Calculate high-precision sample period
segmentCurrent->hpdelta = (hptime_t) (( recordCurrent->record->samprate ) ?
(HPTMODULUS / recordCurrent->record->samprate) : 0.0);
segmentCurrent->timing_qual = timing_qual;
segmentCurrent->calibration_type = calibration_type;
segmentCurrent->firstRecord = segmentCurrent->lastRecord = recordCurrent;
recordCurrent->previous = NULL;
}
recordPrevious = recordCurrent->next;
recordCurrent->next = NULL;
recordCurrent = recordPrevious;
}
// Now loop over all segments, combine the records and free the msr
// structures.
idListCurrent = idListHead;
while (idListCurrent != NULL)
{
segmentCurrent = idListCurrent->firstSegment;
while (segmentCurrent != NULL) {
if (segmentCurrent->datasamples) {
free(segmentCurrent->datasamples);
}
// Allocate data via a callback function.
if (unpack_data != 0) {
segmentCurrent->datasamples = (void *) allocData(segmentCurrent->samplecnt, segmentCurrent->sampletype);
}
// Loop over all records, write the data to the buffer and free the msr structures.
recordCurrent = segmentCurrent->firstRecord;
data_offset = (long long)(segmentCurrent->datasamples);
while (recordCurrent != NULL) {
datasize = recordCurrent->record->samplecnt * ms_samplesize(recordCurrent->record->sampletype);
memcpy((void *)data_offset, recordCurrent->record->datasamples, datasize);
// Free the record.
msr_free(&(recordCurrent->record));
// Increase the data_offset and the record.
data_offset += (long long)datasize;
recordCurrent = recordCurrent->next;
}
segmentCurrent = segmentCurrent->next;
}
idListCurrent = idListCurrent->next;
}
return idListHead;
}
// Function that reads from a MiniSEED binary file from a char buffer and
// returns a LinkedIDList.
LinkedIDList *
readMSEEDBuffer (char *mseed, int buflen, Selections *selections, flag
unpack_data, int reclen, flag verbose, flag details,
long (*allocData) (int, char))
{
int retcode = 0;
int retval = 0;
flag swapflag = 0;
// current offset of mseed char pointer
int offset = 0;
// Unpack without reading the data first
flag dataflag = 0;
// the timing_qual of BLK 1001
uint8_t timing_qual = 0xFF;
// the calibration type, availability of BLK 300, 310, 320, 390, 395
int8_t calibration_type = -1;
// Init all the pointers to NULL. Most compilers should do this anyway.
LinkedIDList * idListHead = NULL;
LinkedIDList * idListCurrent = NULL;
LinkedIDList * idListLast = NULL;
MSRecord *msr = NULL;
ContinuousSegment * segmentCurrent = NULL;
hptime_t lastgap;
hptime_t hptimetol;
hptime_t nhptimetol;
long data_offset;
LinkedRecordList *recordHead = NULL;
LinkedRecordList *recordPrevious = NULL;
LinkedRecordList *recordCurrent = NULL;
int datasize;
//
// Read all records and save them in a linked list.
//
int record_count = 0;
while (offset < buflen) {
msr = msr_init(NULL);
retcode = msr_parse ( (mseed+offset), buflen, &msr, reclen, dataflag, verbose);
if ( ! (retcode == MS_NOERROR)) {
msr_free(&msr);
break;
}
// Test against selections if supplied
if ( selections ) {
char srcname[50];
hptime_t endtime;
msr_srcname (msr, srcname, 1);
endtime = msr_endtime (msr);
if ( ms_matchselect (selections, srcname, msr->starttime, endtime, NULL) == NULL ) {
// Add the record length for the next iteration
offset += msr->reclen;
// Free record.
msr_free(&msr);
continue;
}
}
record_count += 1;
recordCurrent = lrl_init ();
// Append to linked record list if one exists.
if ( recordHead != NULL ) {
recordPrevious->next = recordCurrent;
recordCurrent->previous = recordPrevious;
recordCurrent->next = NULL;
recordPrevious = recordCurrent;
}
// Otherwise create a new one.
else {
recordHead = recordCurrent;
recordCurrent->previous = NULL;
recordPrevious = recordCurrent;
}
recordCurrent->record = msr;
// Determine the byteorder swapflag only for the very first record. The byteorder
// should not change within the file.
// XXX: Maybe check for every record?
if (swapflag <= 0) {
// Returns 0 if the host is little endian, otherwise 1.
flag bigendianhost = ms_bigendianhost();
// Set the swapbyteflag if it is needed.
if ( msr->Blkt1000 != 0) {
/* If BE host and LE data need swapping */
if ( bigendianhost && msr->byteorder == 0 ) {
swapflag = 1;
}
/* If LE host and BE data (or bad byte order value) need swapping */
if ( !bigendianhost && msr->byteorder > 0 ) {
swapflag = 1;
}
}
}
// Actually unpack the data if the flag is not set.
if (unpack_data != 0) {
retval = msr_unpack_data (msr, swapflag, verbose);
}
if ( retval > 0 ) {
msr->numsamples = retval;
}
// Add the record length for the next iteration
offset += msr->reclen;
}
// Return empty id list if no records could be found.
if (record_count == 0) {
idListHead = lil_init();
return idListHead;
}
// All records that match the selection are now stored in a LinkedRecordList
// that starts at recordHead. The next step is to sort them by matching ids
// and then by time.
recordCurrent = recordHead;
while (recordCurrent != NULL) {
// Check if the ID of the record is already available and if not create a
// new one.
// Start with the last id as it is most likely to be the correct one.
idListCurrent = idListLast;
while (idListCurrent != NULL) {
if (strcmp(idListCurrent->network, recordCurrent->record->network) == 0 &&
strcmp(idListCurrent->station, recordCurrent->record->station) == 0 &&
strcmp(idListCurrent->location, recordCurrent->record->location) == 0 &&
strcmp(idListCurrent->channel, recordCurrent->record->channel) == 0 &&
idListCurrent->dataquality == recordCurrent->record->dataquality) {
break;
}
else {
idListCurrent = idListCurrent->previous;
}
}
// Create a new id list if one is needed.
if (idListCurrent == NULL) {
idListCurrent = lil_init();
idListCurrent->previous = idListLast;
if (idListLast != NULL) {
idListLast->next = idListCurrent;
}
idListLast = idListCurrent;
if (idListHead == NULL) {
idListHead = idListCurrent;
}
// Set the IdList attributes.
strcpy(idListCurrent->network, recordCurrent->record->network);
strcpy(idListCurrent->station, recordCurrent->record->station);
strcpy(idListCurrent->location, recordCurrent->record->location);
strcpy(idListCurrent->channel, recordCurrent->record->channel);
idListCurrent->dataquality = recordCurrent->record->dataquality;
}
// Now check if the current record fits exactly to the end of the last
// segment of the current id. If not create a new segment. Therefore
// if records with the same id are in wrong order a new segment will be
// created. This is on purpose.
segmentCurrent = idListCurrent->lastSegment;
if (segmentCurrent != NULL) {
hptimetol = (hptime_t) (0.5 * segmentCurrent->hpdelta);
nhptimetol = ( hptimetol ) ? -hptimetol : 0;
lastgap = recordCurrent->record->starttime - segmentCurrent->endtime - segmentCurrent->hpdelta;
}
if (details == 1) {
/* extract information on calibration BLKs */
calibration_type = -1;
if (recordCurrent->record->blkts) {
BlktLink *cur_blkt = recordCurrent->record->blkts;
while (cur_blkt) {
switch (cur_blkt->blkt_type) {
case 300:
calibration_type = 1;
break;
case 310:
calibration_type = 2;
break;
case 320:
calibration_type = 3;
break;
case 390:
calibration_type = 4;
break;
case 395:
calibration_type = -2;
break;
default:
break;
}
cur_blkt = cur_blkt->next;
}
}
/* extract information based on timing quality */
timing_qual = 0xFF;
if (recordCurrent->record->Blkt1001 != 0) {
timing_qual = recordCurrent->record->Blkt1001->timing_qual;
}
}
if ( segmentCurrent != NULL &&
segmentCurrent->sampletype == recordCurrent->record->sampletype &&
// Test the default sample rate tolerance: abs(1-sr1/sr2) < 0.0001
MS_ISRATETOLERABLE (segmentCurrent->samprate, recordCurrent->record->samprate) &&
// Check if the times are within the time tolerance
lastgap <= hptimetol && lastgap >= nhptimetol &&
segmentCurrent->timing_qual == timing_qual &&
segmentCurrent->calibration_type == calibration_type) {
recordCurrent->previous = segmentCurrent->lastRecord;
segmentCurrent->lastRecord = segmentCurrent->lastRecord->next = recordCurrent;
segmentCurrent->samplecnt += recordCurrent->record->samplecnt;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
}
// Otherwise create a new segment and add the current record.
else {
segmentCurrent = seg_init();
segmentCurrent->previous = idListCurrent->lastSegment;
if (idListCurrent->lastSegment != NULL) {
idListCurrent->lastSegment->next = segmentCurrent;
}
else {
idListCurrent->firstSegment = segmentCurrent;
}
idListCurrent->lastSegment = segmentCurrent;
segmentCurrent->starttime = recordCurrent->record->starttime;
segmentCurrent->endtime = msr_endtime(recordCurrent->record);
segmentCurrent->samprate = recordCurrent->record->samprate;
segmentCurrent->sampletype = recordCurrent->record->sampletype;
segmentCurrent->samplecnt = recordCurrent->record->samplecnt;
// Calculate high-precision sample period
segmentCurrent->hpdelta = (hptime_t) (( recordCurrent->record->samprate ) ?
(HPTMODULUS / recordCurrent->record->samprate) : 0.0);
segmentCurrent->timing_qual = timing_qual;
segmentCurrent->calibration_type = calibration_type;
segmentCurrent->firstRecord = segmentCurrent->lastRecord = recordCurrent;
recordCurrent->previous = NULL;
}
recordPrevious = recordCurrent->next;
recordCurrent->next = NULL;
recordCurrent = recordPrevious;
}
// Now loop over all segments, combine the records and free the msr
// structures.
idListCurrent = idListHead;
while (idListCurrent != NULL)
{
segmentCurrent = idListCurrent->firstSegment;
while (segmentCurrent != NULL) {
if (segmentCurrent->datasamples) {
free(segmentCurrent->datasamples);
}
// Allocate data via a callback function.
if (unpack_data != 0) {
segmentCurrent->datasamples = (void *) allocData(segmentCurrent->samplecnt, segmentCurrent->sampletype);
}
// Loop over all records, write the data to the buffer and free the msr structures.
recordCurrent = segmentCurrent->firstRecord;
data_offset = (long)(segmentCurrent->datasamples);
while (recordCurrent != NULL) {
datasize = recordCurrent->record->samplecnt * ms_samplesize(recordCurrent->record->sampletype);
memcpy((void *)data_offset, recordCurrent->record->datasamples, datasize);
// Free the record.
msr_free(&(recordCurrent->record));
// Increase the data_offset and the record.
data_offset += (long)datasize;
recordCurrent = recordCurrent->next;
}
segmentCurrent = segmentCurrent->next;
}
idListCurrent = idListCurrent->next;
}
return idListHead;
}
void main(void)
{
/* put your own code here */
SET_TCNT_PRESCALE( TCNT_PRESCALE_8);
TSCR1 = TSCR1_INIT;
seg_init();
CANinit(THE_FLOOR);
SET_BITS(LED_DDR, LED1_MASK|LED2_MASK);
node_id = PORTB & 3; //get hardware specified node id
while (!(CANCTL0&0x10));
CANRFLG = 0xC3;
CANRIER = 0x01;
InitializeQueue(&rec); // Create the Recieve Queue
clear_seg();
EnableInterrupts;
for(;;)
{
if(IsQueueEmpty(rec) != 0)
{
DeQueue(&rec);
Parse_Floor();
}
// button 1 press
if((PTJ & (SWITCH1_MASK |SWITCH2_MASK) )== SWITCH1_MASK)
{
if(THE_FLOOR == F1 || THE_FLOOR == F2)
{
if (last != SWITCH1_MASK)
{ // check if button already pressed
data[0] = THE_FLOOR;
data[1] = CALL_SWITCH1;
data[2] = UP;
(void)CANSend(CONTROLLER, 0x00, 0x00, DATA_LENGTH, data);
last = SWITCH1_MASK;
}
}
else if(THE_FLOOR == F3)
{
if (last != SWITCH1_MASK)
{ // check if button already pressed
data[0] = THE_FLOOR;
data[1] = CALL_SWITCH1;
data[2] = DOWN;
(void)CANSend(CONTROLLER, 0x00, 0x00, DATA_LENGTH, data);
last = SWITCH1_MASK;
}
}
}
//button 2 press
else if((PTJ & (SWITCH1_MASK |SWITCH2_MASK) )== SWITCH2_MASK)
{
if(THE_FLOOR == F2)
{
if (last != SWITCH2_MASK)
{ // check if button already pressed
data[0] = THE_FLOOR;
data[1] = CALL_SWITCH2;
data[2] = DOWN;
CANSend(CONTROLLER, 0x00, 0x00, DATA_LENGTH, data);
last = SWITCH2_MASK;
}
}
}
else
last = 0;
// Updates the LED
FORCE_BITS(PTS,0b00001100 , led) ;
} /* loop forever */
/* please make sure that you never leave main */
}
void _main(void)
{
uint32_t i;
/**
*
* Basic setup
*/
/* enable the A20 line */
/* disable the PIC (8259A chip) */
pic_enable(false);
/* disable the local APIC */
//apic_enable(false);
//apic_local_enable(false)
/**
*
* Protection
*/
/* init and enable segmentation */
//gdt_init();
seg_init();
// INFINITE_LOOP();
/* init and enable paging */
//mmu_init();
console_clear();
mmu_init();
/* init the system-call facilities */
sc_init();
/**
*
* Interrupts
*/
// INFINITE_LOOP();
/* init and enable interrupts */
idt_init();
//INFINITE_LOOP();
/* bind stage2 isrs */
//isr_init();
int_init();
ex_init();
//INFINITE_LOOP();
/* configure the Local-APIC timer */
//apic_local_timer_init(0x2ffffff);
//apic_local_timer_init(0xffffff);
/* configure the PIT timer */
pit_init();
printf("Local-APIC init...\n");
/* Init the Local-APIC. */
apic_local_init();
apic_local_set_task_priority(0);
printf("Local-APIC timer config...\n");
apic_local_timer_config(0x2ffffff);
printf("IO-APIC init...\n");
apic_io_init();
/* enable the local APIC */
//apic_enable(true);
apic_local_enable(true);
printf("OK\n");
/* configure the I/O APIC in charge of the PIT, keyboard, ... */
//apic_io_init();
/* STI(); */
/* INFINITE_LOOP(); */
/* clear the screen */
console_clear();
console_init();
/* init the basic I/O services */
stdio_init();
//tty_init();
//tty_activate(0);
/* sysenter(); */
/* vmx_supported(1); */
test_malloc();
/* init the serial number facility */
serial_init();
/* printf("UID %d\n", serial_generate()); */
/* printf("UID %d\n", serial_generate()); */
/* printf("UID %d\n", serial_generate()); */
/* init the task manager */
thread_init();
/* init the scheduler manager */
sched_init();
/* dump the memory */
mem_dump();
/* test the mmu. */
//mmu_test();
/* while (1) */
/* ; */
//video_init();
/* msr = rdmsr(MSR_IA32_APIC_BASE); */
/* printf("msr hi: %x\n", (uint32_t)(msr >> 32)); */
/* printf("msr lo: %x\n", (uint32_t) msr); */
/* msr = rdmsr(MSR_IA32_CR_PAT); */
/* printf("msr hi: %x\n", (uint32_t)(msr >> 32)); */
/* printf("msr lo: %x\n", (uint32_t) msr); */
/* msr = rdmsr(MSR_IA32_PERF_GLOBAL_STATUS); */
/* printf("msr hi: %x\n", (uint32_t)(msr >> 32)); */
/* printf("msr lo: %x\n", (uint32_t) msr); */
/* msr = rdmsr(MSR_IA32_PLATFORM_ID); */
/* printf("msr hi: %x\n", (uint32_t)(msr >> 32)); */
/* printf("msr lo: %x\n", (uint32_t) msr); */
/* printf("Macrotest\n"); */
/* MACROTEST(&msr); */
/* printf("msr hi: %x\n", (uint32_t)(msr >> 32)); */
/* printf("apic-io ver: %x\n", apic_io_get_version()); */
/* printf("apic-io id: %x\n", apic_io_get_id()); */
/* printf("New GDT:\n"); */
/* seg_init(); */
/* printf("Old GDT:\n"); */
/* for (i = 0; i < SEG_DESC_N; i++) */
/* { */
/* printf("%x - %x\n", gdt[i].high, gdt[i].low); */
/* } */
//INFINITE_LOOP();
i = 1 << 5 | 1 << 9;
printf("bsf(i) = %d\n", bsf(i));
printf("bsr(i) = %d\n", bsr(i));
i = 0;
printf("bsr(i) = %d\n", bsr(i));
printf("MSR_IA32_SYSENTER_CS high = %x\n", (uint32_t)(rdmsr(MSR_IA32_SYSENTER_CS) >> 32));
printf("MSR_IA32_SYSENTER_CS low = %x\n", (uint32_t) rdmsr(MSR_IA32_SYSENTER_CS));
printf("IA32_CR_PAT high = %x\n", (uint32_t)(rdmsr(MSR_IA32_CR_PAT) >> 32));
printf("IA32_CR_PAT low = %x\n", (uint32_t) rdmsr(MSR_IA32_CR_PAT));
/* jump to background task - code after this function is never reached */
sched_launch();
/* test_multiline(); */
/* test_println(); */
/* test_interrupts(); */
/* test_itoa(); */
/* test_msr(); */
//test_apic();
//test_ide_dma();
//printf("+ Bus 0\n", BG_BLACK | FG_RED | FG_INTENSITY);
//pci_list(0, 2, 64);
/* printf("Bus 1\n", BG_BLACK | FG_RED | FG_INTENSITY); */
/* pci_list(1); */
//test_ide_dma();
//test_apic();
//fprintf(0, "Protos v%d.%d - id:%x\n", 0, 12, 0xbe01);
//fprintf(0, "\tid reg:\t%r\n", 0xbe01);
//fprintf(0, "Ok!\n");
// printf("Helo %% %d-%x-%r\n", 45, 0xabc78, 0xabc78);
//printf("Helo %r\n", 0xbe01);
//r = fprintf(stdout, "Almost %x years :)\n", 26);
//fprintf(stdout, "size:%d\n", strlen("hello!"));
//printf("fprintf result = %d\n", r);
//printf(&((&stdio_filedes[0])->buffer[0]));
//__asm__ ("rdtsc");
// Halt the system
while (1)
HLT();
}
/*----------------------------------------------------------------------------*/
void init_seg_lcd_disp(void)
{
clear_seg_lcd();
seg_init();
com_init();
}
void
seg_zero(struct segment *seg)
{
seg_init(seg, 0, 0, 0);
}