Subversion Repositories yac

/***************************************************************************
*                                                                          *
*  File           : main.c                                                 *
*  Project        : YAC (Yet Another CORDIC Core)                          *
*  Creation       : Jun. 2015                                              *
*  Limitations    :                                                        *
*  Platform       : Linux                                                  *
*  Target         : Open Risc MCU (test-system)                            *
*                                                                          *
*  Author(s):     : Christian Haettich                                     *
*  Email          : feddischson@opencores.org                              *
*                                                                          *
*                                                                          *
**                                                                        **
*                                                                          *
*  Description                                                             *
*        C implementation for a test system: Or32 part.                    *
*        This implementation receives messages via serial line.            *
*        Each message contains a calculation request, and each answer      *
*        contains the calculation result                                   *
*        All messages have the same size, starting with a synchronization  *
*        byte and a header byte.                                           *
*                                                                          *
*                                                                          *
****************************************************************************
*                                                                          *
*                     Copyright Notice                                     *
*                                                                          *
*    This file is part of YAC - Yet Another CORDIC Core                    *
*    Copyright (c) 2015, Author(s), All rights reserved.                   *
*                                                                          *
*    YAC is free software; you can redistribute it and/or                  *
*    modify it under the terms of the GNU Lesser General Public            *
*    License as published by the Free Software Foundation; either          *
*    version 3.0 of the License, or (at your option) any later version.    *
*                                                                          *
*    YAC is distributed in the hope that it will be useful,                *
*    but WITHOUT ANY WARRANTY; without even the implied warranty of        *
*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
*    Lesser General Public License for more details.                       *
*                                                                          *
*    You should have received a copy of the GNU Lesser General Public      *
*    License along with this library. If not, download it from             *
*    http://www.gnu.org/licenses/lgpl                                      *
*                                                                          *
***************************************************************************/
#include "interconnect.h"
#include "support.h"
#include "or1200.h"
 
#include "uart.h"
#include "board.h"
#include <stdint.h>
#include "msg.h"
#include "yac.h"
#include "crc.h"
 
 
static uint8_t byte_cnt;
static uint8_t in_sync;
static void update_buf( uint8_t c );
static void proceed_msg( Msg * m );
 
 
/* our yac instance */
static YAC yac;
 
 
 
int main()
{
  uart_init( UART_BASE );
  empty_RX( ); 
 
  in_sync  = 0;
  byte_cnt = 0;
 
  yac_init( &yac,
            YAC_BASE,
            YAC_XY_WIDTH,
            YAC_A_WIDTH,
            YAC_RM_GAIN,
            YAC_N_ENTRIES );
 
 
  while(1)
  {
    update_buf( uart_getc() );
  }
}
 
 
/* serial decoding and synchronization */
void update_buf( uint8_t c )
{
  /* input buffer */
  static Msg buf;
 
 
  if( 0 == in_sync && SYNC_BYTE == c )
  {
    in_sync = 1;
    byte_cnt = 1;
    buf.bytes[ 0 ] = c;
  }
  else 
  if( 1 == in_sync && byte_cnt < sizeof( Msg ) )
  {
    buf.bytes[ byte_cnt ] = c;
    byte_cnt++;
  }
  else 
  if( 1 == in_sync && 0 == byte_cnt )
  {
    byte_cnt++;
    if( SYNC_BYTE == c )
      buf.bytes[ 0 ] = c;
    else
      in_sync = 0;
  }
 
 
  /* we are synchronized and have a full message */
  if( in_sync && byte_cnt == sizeof( Msg ) )
  {
    byte_cnt = 0;
    proceed_msg( &buf );
  }
 
}
 
void proceed_msg( Msg * m )
{
  uint8_t crc_in = crc( m->bytes, sizeof( Msg )-1 );
  if( crc_in != m->fields.crc )
  {
    /* Ignore message!
     * The pc will handle the situation, that
     * he doesn't get a response!
     */
  }
  else 
  if( CMD_NOP == m->fields.header )
  {
    /* simple echo */
    uart_write( (char*)m->bytes, sizeof( Msg ) );
  }
 
  else
  if( CMD_CALC == m->fields.header )
  {
 
    /* please note: we extract the message fields to the stack
     * because of some "Program received signal SIGBUS, Bus error. ... incomplete sequence" 
     * problem. It seems there is some problem with the alignment 
     * (or maybe something else, but the problem does not occur if there is no pragma pack in msg.h)
     * 
     * */
    int32_t x, xx, y, yy, a, aa;
    uint8_t mode;
 
    /* extract */
    x    = m->fields.payload[0];
    y    = m->fields.payload[1];
    a    = m->fields.payload[3];
    mode = m->fields.mode;
 
    /* do the calculation */
    yac_single( &yac, 
        &x, &y, &a, &xx, &yy, &aa, &mode );
 
    /* put back the result */
    m->fields.payload[ 0 ] = xx;
    m->fields.payload[ 1 ] = yy;
    m->fields.payload[ 2 ] = aa;
 
    /* calculate the crc*/
    m->fields.crc = crc( m->bytes, sizeof( Msg )-1 );
 
    /* write out the message */
    uart_write( (char*)&m->bytes[0], sizeof( Msg ) );
  }
 
}