|
|
#include <..\header\LPP_spwAPI.h>
|
|
|
#include <..\header\basic_parameters.h>
|
|
|
#include <..\header\ccsds_types.h>
|
|
|
#include <stdio.h>
|
|
|
#include <stdlib.h>
|
|
|
#include <asm-leon/timer.h>
|
|
|
#include <asm-leon/irq.h>
|
|
|
|
|
|
#define FINE_TIME_RESET time_manager_regs->ctrl = 0x00000001;
|
|
|
|
|
|
volatile int didtick = 0;
|
|
|
volatile int cnt = 0;
|
|
|
volatile int dide = 0;
|
|
|
|
|
|
struct timerevent e; /* this has to be a global variable, it is inserted in a linked list by addtimer() */
|
|
|
struct irqaction action_receive_CCSDS; /* this has to be a global variable as it will be inserted in a list */
|
|
|
void register_event();
|
|
|
|
|
|
int event(void *arg)
|
|
|
{
|
|
|
dide = 1;
|
|
|
register_event();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void register_event()
|
|
|
{
|
|
|
/* add an event 1s from now */
|
|
|
do_gettimeofday((struct timeval*) &e.expire);
|
|
|
e.handler = event;
|
|
|
e.expire.tv_sec = e.expire.tv_sec + 1;
|
|
|
addtimer(&e);
|
|
|
}
|
|
|
|
|
|
int main()
|
|
|
{
|
|
|
volatile char *rx;
|
|
|
char *tx;
|
|
|
volatile char *rmaphdr;
|
|
|
volatile char *rmap;
|
|
|
volatile int *rxd;
|
|
|
volatile int *txd;
|
|
|
int size;
|
|
|
int i;
|
|
|
int j;
|
|
|
unsigned char current_nb_average = 0;
|
|
|
spwHeader_t spwHeader;
|
|
|
|
|
|
grspwregs_t *grspw_regs;
|
|
|
time_manager_regs_t *time_manager_regs;
|
|
|
spectral_matrices_regs_t *spectral_matrices_regs;
|
|
|
|
|
|
grspw_regs = (grspwregs_t*) GRSPW_APB_ADDR; // the grspw registers are at the address GRSPW_APB_ADDR
|
|
|
time_manager_regs = (time_manager_regs_t*) LPP_TIME_MANAGER; // the time manager registers are at the address LPP_TIME_MANAGER
|
|
|
spectral_matrices_regs = (spectral_matrices_regs_t*) LPP_SPECTRAL_MATRIX_CTRL; // the spectral matrices registers are at this address
|
|
|
|
|
|
rx = (char*) malloc(64);
|
|
|
tx = (char*) malloc(64);
|
|
|
rmaphdr = (char*) malloc(32);
|
|
|
rmap = (char*) malloc(64);
|
|
|
rxd = (int*) almalloc(1024); // memory allocation for the receiver descriptors table
|
|
|
// almalloc => 1024 bytes aligned address
|
|
|
txd = (int*) almalloc(1024); // memory allocation for the transmitter descriptors table
|
|
|
// almalloc => 1024 bytes aligned address
|
|
|
|
|
|
// GRSPW initilization
|
|
|
spw_reset(grspw_regs); // RESET THE SPACEWIRE LINK
|
|
|
spw_init(NODEADDR, CLKDIV, DESTKEY, RXMAXLEN, grspw_regs); // INITIALIZE THE SPACEWIRE REGISTERS
|
|
|
enable_timecode_reception(grspw_regs); // enable time-code reception
|
|
|
|
|
|
while( grspw_link_state(grspw_regs) != SPW_LINK_STATE_RUN ) {} // wait for the link to be in run state
|
|
|
|
|
|
// INITIALIZE THE TRANSMITTER RECEIVER DESCRIPTORS TABLES
|
|
|
for(i=0; i<8; i++) { // initialize the receiver and transmitter descriptor tables
|
|
|
rxd[i] = 0;
|
|
|
txd[i] = 0;
|
|
|
}
|
|
|
grspw_regs->txdesc = (int) txd;
|
|
|
grspw_regs->rxdesc = (int) rxd;
|
|
|
|
|
|
for (j=0; j<64; j++){ // initialize the rx and tx data tables
|
|
|
rx[j] = j;
|
|
|
tx[j] = 10;
|
|
|
}
|
|
|
|
|
|
// INITIALIZE THE TRANSMISSION
|
|
|
spwHeader.targetLogicalAddress = 0x21; // initialize the SpaceWire Header
|
|
|
spwHeader.protocolIdentifier = 0x02;
|
|
|
spwHeader.reserved = 0x00;
|
|
|
spwHeader.userApplication = 0x00;
|
|
|
set_txd(tx, 32, (char*) &spwHeader, HEADERLEN, txd); // initialize the transmitter descriptor 0
|
|
|
|
|
|
INIT_CCSDS_TELEMETRY_HEADER
|
|
|
|
|
|
// INITIALIZE THE RECEPTION
|
|
|
enable_receiver_descriptor(rx, rxd); // enable the reception of a SpaceWire packet
|
|
|
|
|
|
// START SPW TRANSMISSION / RECEPTION
|
|
|
grspw_regs->dmactrl = GRSPW_DMACTRL_NS | GRSPW_DMACTRL_RD | GRSPW_DMACTRL_RI | GRSPW_DMACTRL_RE | GRSPW_DMACTRL_TE;
|
|
|
// NS = 1 wait for a descriptor to be activated
|
|
|
// RD = 1 there are enabled descriptors
|
|
|
// RI = 1 receive interrupts
|
|
|
// RE = 1 receiver enabled
|
|
|
// TE = 1 transmitter enabled
|
|
|
|
|
|
// TIME FUNCTIONS
|
|
|
leonbare_init_ticks(); // initialize the time abilities of the Leon3
|
|
|
register_event(); // create an event
|
|
|
|
|
|
// SETS AN IRQ HANDLER UPON RECEPTION OF A SPACEWIRE PACKET
|
|
|
spacewire_PARAMETERS.size = &size; // size of the receive packet
|
|
|
spacewire_PARAMETERS.rx = rx; // location of the data
|
|
|
spacewire_PARAMETERS.rxd = rxd; // associated descriptor
|
|
|
spacewire_PARAMETERS.tx = tx; // location of the data
|
|
|
spacewire_PARAMETERS.txd = txd; // associated descriptor
|
|
|
spacewire_PARAMETERS.regs = grspw_regs; // grspw module registers
|
|
|
action_receive_CCSDS.handler = (irqhandler) irqhandler_receive_CCSDS; // create the irq handler
|
|
|
chained_catch_interrupt(GRSPW_IRQ, &action_receive_CCSDS); // associate the handler with the GRSPW_IRQ
|
|
|
enable_irq(GRSPW_IRQ); // enable the interruption driven by the grspw module upon reception of a packet
|
|
|
|
|
|
packet_type.time_packet = 0;
|
|
|
packet_type.tc_packet = 0;
|
|
|
|
|
|
//write spectral matrices location in the registers
|
|
|
spectral_matrices_regs->address1 = (unsigned int) spectral_matrix_f0_a;
|
|
|
spectral_matrices_regs->address2 = (unsigned int) spectral_matrix_f0_b;
|
|
|
|
|
|
printf("let's work...\n");
|
|
|
|
|
|
while(1) { // infinite loop
|
|
|
if (packet_type.time_packet == 1) {
|
|
|
FINE_TIME_RESET
|
|
|
time_manager_regs->next_coarse_time = (rx[10+4]<<24) + (rx[11+4]<<16) + (rx[12+4]<<8) + (rx[13+4]);
|
|
|
send_fine_time(time_manager_regs->fine_time);
|
|
|
enable_receiver_descriptor(spacewire_PARAMETERS.rx, spacewire_PARAMETERS.rxd);
|
|
|
enable_receiver(spacewire_PARAMETERS.regs);
|
|
|
packet_type.time_packet = 0;
|
|
|
}
|
|
|
if ((spectral_matrices_regs->ctrl & 1) == 1) {
|
|
|
FINE_TIME_RESET
|
|
|
for (i=0; i<TOTAL_SIZE_SPECTRAL_MATRIX; i++) {
|
|
|
averaged_spectral_matrix_f0[i] = averaged_spectral_matrix_f0[i] + spectral_matrix_f0_a[i];
|
|
|
}
|
|
|
send_fine_time(time_manager_regs->fine_time);
|
|
|
spectral_matrices_regs->ctrl = spectral_matrices_regs->ctrl & 0xfffffffe;
|
|
|
current_nb_average++;
|
|
|
}
|
|
|
if ( ( (spectral_matrices_regs->ctrl>>1) & 1) == 1) {
|
|
|
FINE_TIME_RESET
|
|
|
for (i=0; i<TOTAL_SIZE_SPECTRAL_MATRIX; i++) {
|
|
|
averaged_spectral_matrix_f0[i] = averaged_spectral_matrix_f0[i] + spectral_matrix_f0_b[i];
|
|
|
}
|
|
|
send_fine_time(time_manager_regs->fine_time);
|
|
|
spectral_matrices_regs->ctrl = spectral_matrices_regs->ctrl & 0xfffffffd;
|
|
|
current_nb_average++;
|
|
|
}
|
|
|
if ( current_nb_average == NB_AVERAGE_NORMAL_f0 ) {
|
|
|
FINE_TIME_RESET
|
|
|
for(i=0;i<NB_BINS_COMPRESSED_MATRIX_f0;i++){
|
|
|
j = 17 + i * 8;
|
|
|
compressed_spectral_matrix_f0[i]= (averaged_spectral_matrix_f0[j]
|
|
|
+ averaged_spectral_matrix_f0[j+1]
|
|
|
+ averaged_spectral_matrix_f0[j+2]
|
|
|
+ averaged_spectral_matrix_f0[j+3]
|
|
|
+ averaged_spectral_matrix_f0[j+4]
|
|
|
+ averaged_spectral_matrix_f0[j+5]
|
|
|
+ averaged_spectral_matrix_f0[j+6]
|
|
|
+ averaged_spectral_matrix_f0[j+7])/(8*NB_AVERAGE_NORMAL_f0);
|
|
|
}
|
|
|
|
|
|
BP1_set(); // computation of the BP1 set and building of the corresponding telemetry product
|
|
|
|
|
|
// sending of the BP1 set
|
|
|
set_txd( LFR_BP1_F0, NB_BINS_COMPRESSED_MATRIX_f0*9, // initialize the transmitter descriptor 0
|
|
|
(char*) &ccsdsTelemetryHeader, CCSDS_TELEMETRY_HEADER_LENGTH, txd );
|
|
|
enable_transmitter_descriptor(CCSDS_TELEMETRY_HEADER_LENGTH, spacewire_PARAMETERS.txd); // enable the descriptor for transmission
|
|
|
enable_transmitter(spacewire_PARAMETERS.regs); // enable the transmission
|
|
|
|
|
|
for (i=0; i<TOTAL_SIZE_SPECTRAL_MATRIX; i++) {
|
|
|
averaged_spectral_matrix_f0[i] = 0;
|
|
|
}
|
|
|
//send_fine_time(time_manager_regs->fine_time);
|
|
|
current_nb_average = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
|
