Ejemplo n.º 1
0
void MakeLog(void){
	uint16_t crc_main = 0xffff;
	if (gf_buffer_indicator == 1){	//if this flag is 1 we must send the g_buffer_uSD_2
		for (uint16_t i=0;i<BUFFER_SIZE-2;i++)	{	//calculating the CRC
			crc_main = (uint16_t)(crc_main + g_buffer_uSD_2[i]);
		}
		g_buffer_uSD_2[BUFFER_SIZE-1] = lo8(crc_main);
		g_buffer_uSD_2[BUFFER_SIZE-2] = hi8(crc_main);
		
		g_error = f_lseek(&f_origem, f_size(&f_origem));					//looks for the end of the file
		//TODO:: do something with those errors
		g_error = f_write(&f_origem, g_buffer_uSD_2, BUFFER_SIZE, &br);		//write the buffer on the end of the file
		g_error = f_sync(&f_origem);										//waits for it to finish
	}	
	else{ //if gf_buffer_indicator is 0 we must send the g_buffer_uSD
		for (uint16_t i=0;i<BUFFER_SIZE-2;i++)	{//calculating the CRC
			crc_main = (uint16_t)(crc_main + g_buffer_uSD[i]);
		}
		g_buffer_uSD[BUFFER_SIZE-1] = lo8(crc_main);
		g_buffer_uSD[BUFFER_SIZE-2] = hi8(crc_main);
		
		g_error = f_lseek(&f_origem, f_size(&f_origem));
		//TODO:: do something with this error
		g_error = f_write(&f_origem, g_buffer_uSD, BUFFER_SIZE, &br);
		g_error = f_sync(&f_origem);
	}//close else
}
Ejemplo n.º 2
0
Archivo: ppm.c Proyecto: eknl/gt3b
/*
    TIM3 overflow interrupt
    set next prescaler, output compare and overflow values to
      preload registers
*/
@interrupt void ppm_interrupt(void) {
    BRES(TIM3_SR1, 0);	// erase interrupt flag

    if (ppm_channel2) {
	if (ppm_channel2 == 2) {
	    // will be setting channel1 servo, so we are now generating
	    // SYNC signal in HW
	    // wakeup CALC task to compute new PPM values
	    // values for ARR registers will be updated after calculate done
	    // (and when we are still generating SYNC pulse)
	    awake(CALC);
	}
	// set servo channel
	TIM3_PSCR = PPM_PSC_SERVO;
	TIM3_CCR2H = hi8(PPM_300US_SERVO);
	TIM3_CCR2L = lo8(PPM_300US_SERVO);
	TIM3_ARRH = ppm_values[ppm_channel2];
	ppm_channel2++;
	TIM3_ARRL = ppm_values[ppm_channel2];
	if (++ppm_channel2 > channels2) {
	    // next to SYNC pulse
	    ppm_channel2 = 0;
	}
	return;
    }

    // set SYNC signal
    TIM3_PSCR = PPM_PSC_SYNC;
    TIM3_CCR2H = hi8(PPM_300US_SYNC);
    TIM3_CCR2L = lo8(PPM_300US_SYNC);
    TIM3_ARRH = ppm_values[0];
    TIM3_ARRL = ppm_values[1];
    ppm_channel2 = 2;  // to first channel (step 2 bytes)
}
Ejemplo n.º 3
0
Archivo: ppm.c Proyecto: eknl/gt3b
// set number of channels
void ppm_set_channels(u8 n) {
    // disable PPM generation till new values will not be set
    ppm_enabled = 0;
    BRES(TIM3_CR1, 0);	// disable timer
    BSET(PD_ODR, 0);	// set PPM pin to 1

    // start with generating 20ms SYNC signal
    TIM3_CCR2H = hi8(PPM_300US_SYNC);
    TIM3_CCR2L = hi8(PPM_300US_SYNC);
    TIM3_ARRH = hi8(PPM_MUL_SYNC * 20);
    TIM3_ARRL = lo8(PPM_MUL_SYNC * 20);

    channels = n;
    channels2 = (u8)(n << 1);  // also 2* value for compare in ppm_interrupt
}
Ejemplo n.º 4
0
void trtCreateTask(void (*fun)(void*), uint16_t stacksize, uint32_t release, uint32_t deadline, void *args) {

  uint8_t *sp;
  struct task *t;
  int i;

  cli(); // turn off interrupts

  ++kernel.nbrOfTasks;

  sp = kernel.memptr;
  kernel.memptr -= stacksize;  // decrease free mem ptr

  // initialize stack
  *sp-- = lo8(fun);       // store PC(lo)
  *sp-- = hi8(fun);       // store PC(hi)
  for (i=0; i<25; i++)    //WAS -- for (i=0; i<24; i++)
    *sp-- = 0x00;         // store SREG,r0-r1,r3-r23

  // Save args in r24-25 (input arguments stored in these registers)
  *sp-- = lo8(args);
  *sp-- = hi8(args);

  for (i=0; i<6; i++)
    *sp-- = 0x00;         // store r26-r31

  t = &kernel.tasks[kernel.nbrOfTasks];

  t->release = release;
  t->deadline = deadline;
  t->state = TIMEQ;

  t->spl = lo8(sp);       // store stack pointer
  t->sph = hi8(sp);
  
  // call interrupt handler to schedule
  TIMER1_COMPA_vect();

}
Ejemplo n.º 5
0
void rgb( uint8_t h, uint8_t s, uint8_t v,
		uint8_t *r, uint8_t *g, uint8_t *b )
{
	uint8_t f, hi;
    int16_t p, q, t;

	hi = hi8( h );
    f = f8( h );
    p = p8( v, s );
    q = q8( v, s, f );
    t = t8( v, s, f );

	switch ( hi ) {
	case 0:
		*r = v;
        *g = t;
        *b = p;
        break;
	case 1:
        *r = q;
		*g = v;
        *b = p;
		break;
	case 2:
        *r = p;
		*g = v;
        *b = t;
		break;
	case 3:
        *r = p;
        *g = q;
		*b = v;
		break;
	case 4:
        *r = t;
        *g = p;
		*b = v;
		break;
	case 5:
		*r = v;
        *g = p;
        *b = q;
		break;
	default:
		exit( EXIT_FAILURE );
		break;
	}
}
Ejemplo n.º 6
0
void rgb( uint8_t h, uint8_t s, uint8_t v,
		uint8_t *r, uint8_t *g, uint8_t *b )
{
	uint8_t f, hi;

	hi = hi8( h );
	f = f8( h );

	switch ( hi ) {
	case 0:
		*r = v;
		*g = t8( v, s, f );
		*b = p8( v, s );
		break;
	case 1:
		*r = q8( v, s, f );
		*g = v;
		*b = p8( v, s );
		break;
	case 2:
		*r = p8( v, s );
		*g = v;
		*b = t8( v, s, f );
		break;
	case 3:
		*r = p8( v, s );
		*g = q8( v, s, f );
		*b = v;
		break;
	case 4:
		*r = t8( v, s, f );
		*g = p8( v, s );
		*b = v;
		break;
	case 5:
		*r = v;
		*g = p8( v, s );
		*b = q8( v, s, f );
		break;
	default:
		/*	not reached	*/
		break;
	}
}
Ejemplo n.º 7
0
Archivo: krnl.c Proyecto: jdn-aau/krnl
struct k_t *
k_crt_task (void (*pTask) (void), char prio, char *pStk, int stkSize)
{
    struct k_t *pT;
    int i;
    char *s;

    if ((k_running) || ((prio <= 0) || (DMY_PRIO < prio))
	|| (k_task <= nr_task)) {
	goto badexit;
    }

    pT = task_pool + nr_task;	// lets take a task descriptor
    pT->nr = nr_task;
    nr_task++;

    pT->cnt2 = 0;		// no time out running on you for the time being
    pT->cnt3 = 0;		// no time out semaphore

    pT->cnt1 = (int) (pStk);	// ref to my stack

    // stack paint :-)
    for (i = 0; i < stkSize; i++)	// put hash code on stak to be used by k_unused_stak()
    {
	pStk[i] = STAK_HASH;
    }

    s = pStk + stkSize - 1;	// now we point on top of stak
    *(s--) = 0x00;		// 1 byte safety distance :-)

    // an interrupt do only push PC on stack by HW - can be 2 or 3 bytes
    // depending of 368/.../1280/2560
#ifdef BACKSTOPPER
    pT->pt = pTask;
    *(s--) = lo8 (jumper);	//  so top now holds address of function
    *(s--) = hi8 (jumper);	// which is code body for task
#else
    *(s--) = lo8 (pTask);	//  so top now holds address of function
    *(s--) = hi8 (pTask);	// which is code body for task
#endif
    // NB  NB 2560 use 3 byte for call/ret addresses the rest only 2
#if defined (__AVR_ATmega2560__) || defined(__AVR_ATmega2561__)
    *(s--) = EIND;		// best guess : 3 byte addresses !!! or just 0
#endif

    // r1 is the socalled zero value register
    // see https://gcc.gnu.org/wiki/avr-gcc
    // can tmp be non zero (multiplication etc)
    *(s--) = 0x00;		// r1
    *(s--) = 0x00;		// r0
    *(s--) = 0x00;		// sreg

    //1280 and 2560 need to save rampz reg just in case
#if defined (__AVR_ATmega2560__) || defined (__AVR_ATmega1280__) || defined (__AVR_ATmega1284P__) || defined(__AVR_ATmega2561__)
    *(s--) = RAMPZ;		// best guess  0x3b
    // obsolete JDN    *(s--) = EIND;             // best guess
#endif

#if defined (__AVR_ATmega2560__) || defined (__AVR_ATmega1280__) || defined(__AVR_ATmega2561__)
    *(s--) = EIND;		// best guess 0x3c
#endif

    for (i = 0; i < 30; i++)	//r2-r31 = 30 regs
    {
	*(s--) = 0x00;
    }

    pT->sp_lo = lo8 (s);	// now we just need to save stakptr
    pT->sp_hi = hi8 (s);	// in thread descriptor

    // HW DEPENDENT PART - ENDE

    pT->prio = prio;		// maxv for holding org prio for inheritance
    pT->maxv = (int) prio;
    prio_enQ (pAQ, pT);		// and put task in active Q

    return (pT);

  badexit:
    k_err_cnt++;
    return (NULL);
}
Ejemplo n.º 8
0
struct k_t *
k_crt_task (void (*pTask) (void), char prio, char *pStk, int stkSize)
{

  struct k_t *pT;
  int i;
  char *s;

  if (k_running)
    return (NULL);

  if ((prio <= 0 ) || (DMY_PRIO < prio)) {
    pT = NULL;
    goto badexit;
  }

  if (k_task <= nr_task) {
    goto badexit;
  }

  pT = task_pool + nr_task;	// lets take a task descriptor
  nr_task++;

  pT->cnt2 = 0;		// no time out running on you for the time being

  // HW_DEP_START
  // inspiration from http://dev.bertos.org/doxygen/frame_8h_source.html
  // and http://www.control.aau.dk/~jdn/kernels/krnl/
  // now we are going to precook stak
  
  pT->cnt1 = (int) (pStk);

  for (i = 0; i < stkSize; i++)	// put hash code on stak to be used by k_unused_stak()
    pStk[i] = STAK_HASH;

  s = pStk + stkSize - 1;	// now we point on top of stak
  *(s--) = 0x00;		// 1 byte safety distance
  *(s--) = lo8 (pTask);	//  so top now holds address of function
  *(s--) = hi8 (pTask);	// which is code body for task

  // NB  NB 2560 use 3 byte for call/ret addresses the rest only 2
#if defined (__AVR_ATmega2560__)
  *(s--) = EIND;		// best guess : 3 byte addresses !!!
#endif

  *(s--) = 0x00;		// r1
  *(s--) = 0x00;		// r0
  *(s--) = 0x00;		// sreg

  //1280 and 2560 need to save rampz reg just in case
#if defined (__AVR_ATmega2560__) || defined (__AVR_ATmega1280__)
  *(s--) = RAMPZ;		// best guess
  *(s--) = EIND;		// best guess
#endif

  for (i = 0; i < 30; i++)	//r2-r31 = 30 regs
    *(s--) = 0x00;

  pT->sp_lo = lo8 (s);	// now we just need to save stakptr
  pT->sp_hi = hi8 (s);	// in thread descriptor
  //HW_DE_ENDE

  pT->prio = prio;		// maxv for holding org prio for inheritance
  pT->maxv = (int) prio;
  prio_enQ (pAQ, pT);		// and put task in active Q

  return (pT);		// shall be index to task descriptor

 badexit:
  k_err_cnt++;
  return (NULL);
}
Ejemplo n.º 9
0
int16_t f8( uint8_t h ) {
	uint8_t hi = hi8( h );

	return (uint16_t) (h - buckets_8[hi]) * 255 / bsize_8[hi];
}