示例#1
0
    //----------------------------------------------------------------------
    //Render::Render(GLuint pos, GLuint col, int n, CL* cli, RTPSettings& _settings) :
    //settings(_settings)
    //{
    //}
    //----------------------------------------------------------------------
    Render::Render(GLuint pos, GLuint col, int n, CL* cli, RTPSettings* _settings)
    {
        this->settings = _settings;
     
        shader_source_dir = settings->GetSettingAs<string>("rtps_path");
        shader_source_dir += "/shaders";
        printf("SHADER SOURCE DIR\n", shader_source_dir.c_str());

        rtype = POINTS;
        pos_vbo = pos;
        col_vbo = col;
        this->cli=cli;
        num = n;
        window_height=600;
        window_width=800;
        near_depth=0.;
        far_depth=1.;
        write_framebuffers = false;
        GLubyte col1[] = {0,0,0,255};
        GLubyte col2[] = {255,255,255,255};

        generateCheckerBoardTex(col1,col2,8,640);
        printf("GL VERSION %s\n", glGetString(GL_VERSION));
        //blending = settings.GetSettingAs<bool>("Render: Blending");
        //blending = settings->getUseAlphaBlending();
        blending = settings->GetSettingAs<bool>("render_use_alpha");
        setupTimers();
    }
示例#2
0
int main(void)
{
	DO_TEST_HARNESS_SETUP();
	
	WD_DISABLE();
	
	setupIO();
	readTestMode();
		
	setupTimers();
	
	smIndex = setupStateMachine();
	
	TS_Setup();
	
	Threshold_Init();
	
	Filter_Init();
	
	Flush_Reset();
		
	COMMS_Init();
		
	sei();
	
	runNormalApplication();
}	
示例#3
0
void setupAttiny() {
  DDRB set(LED);
  PORTB clr(LED);
  cli();
  setupTimers();
  sei();
}
void TimerController::checkForStart(unsigned char channel)
{
  Duration duration;

  if(_stateMachine->isStartTimer())
  {
    _stateMachine->clearStartTimer();
    switch (_stateMachine->getState())
    {
      case TEST:
        colour = 0;
        if (DEBUG) Serial.println("TimerController - Starting Timer - State: TEST");
        duration.duration = 0;
        duration.t2_prescaler_pointer = (unsigned long) WAIT_T2_PRESCALER_POINTER;
        duration.t2_comparator = (unsigned long) WAIT_T2_COMPARATOR;
        duration.t1_comparator = (unsigned long) WAIT_T1_COMPARATOR;
        setupTimers(duration);
      break;

      case WAIT:
        colour = 0;
        if (DEBUG) Serial.println("TimerController - Starting Timer - State: WAIT");
        duration.duration = 0;
        duration.t2_prescaler_pointer = (unsigned long) WAIT_T2_PRESCALER_POINTER;
        duration.t2_comparator = (unsigned long) WAIT_T2_COMPARATOR;
        duration.t1_comparator = (unsigned long) WAIT_T1_COMPARATOR;
        setupTimers(duration);
      break;

      case DISPLAY_COLOUR:
        colour = _stateMachine->getColour() + 2;
        if (DEBUG)
        {
          Serial.print("TimerController:  Starting Timer: DISPLAY_COLOUR : Channel ");
          Serial.println(channel, HEX);
          Serial.print("Colour: ");
          Serial.println(_stateMachine->getColour(), HEX);
        }
        duration = _durations[channel][_stateMachine->getColour()];
        setupTimers(duration);
      break;

      default:
        if (DEBUG) Serial.println("TimerController - State: DEFAULT");
    }
  }
}
示例#5
0
ProjectSettings::ProjectSettings(int argc, char** argv, int mpi_rank):
    cwd(".")
{
    setupTimers();
    this->default_config();

    this->parseCommandLineArgs(argc, argv, mpi_rank);
    this->ParseFile(cli_filename);
}
示例#6
0
void init(void) {
    setupFlash();
    setupClocks();
    setupNVIC();
    systick_init(SYSTICK_RELOAD_VAL);
    gpio_init_all();
    afio_init();
    setupADC();
    setupTimers();
    setupUSB();
    boardInit();
}
示例#7
0
void init(void) {
    setupFlash();
    setupClocks();
    setupNVIC();
    systick_init(SYSTICK_RELOAD_VAL);
    gpio_init_all();
    afio_init();
    setupADC();
    setupTimers();
    //    usb_cdcacm_enable(BOARD_USB_DISC_DEV, BOARD_USB_DISC_BIT);
    boardInit();
}
示例#8
0
void init(void) {
    setupFlash();
    setupClocks();
    setupNVIC();
    systick_init(SYSTICK_RELOAD_VAL);
    gpio_init_all();
    afio_init();
    setupADC();
    setupTimers();
//    setupUSB();
#if !defined(BOARD_STM32VLD)
    setupUSB();
#endif
    boardInit();
}
示例#9
0
int main(void)
{
    // Call setup functions
    setupSerial();
    setupTimers();
    setupADC();
    
    // Set external interrupts
    sei();
    
    while (1)
    {
        // Infinite loop
    }
    
    return 0;
}
示例#10
0
void init(void) {
    setupFlash();
// ok
    setupClocks();
// ok
    setupNVIC();
// ok
    systick_init(SYSTICK_RELOAD_VAL);
// ok
    gpio_init_all();
// ok
    afio_init();
// ok
    setupADC();
// adcs increase mA!
    setupTimers();
}
示例#11
0
void MainWindow::realAddTorrent(QString torrentFile, QString torrentPath, QString mountPath) {
    if (!QFile::exists(torrentFile) && !isMagnet(torrentFile))
        die("torrent file not found");

    standartText = ("Torrent file: " + torrentFile + "\nDownload path: " + torrentPath + "\nMount path: " + mountPath + "\n").toLocal8Bit();
    standartTextLen = standartText.size();
    updateStandartText();

    if (torrentPath[torrentPath.length() - 1] != QChar('/'))
        torrentPath += "/";
    if (mountPath[mountPath.length() - 1] != QChar('/'))
        mountPath += "/";

    resumeSavePath = torrentPath;

    add_torrent_params p;
    p.storage_mode = libtorrent::storage_mode_allocate;

    if (isMagnet(torrentFile)) {
        int i;
        for (i = 1; torrentFile[i] != '='; i++);
        for (i = i + 1; torrentFile[i] != '='; i++);

        QString url;
        for (i = i + 1; torrentFile[i] != '&'; i++)
            url += torrentFile[i];

#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
        QString name = QUrl(url).toString().replace("+", " ");
#else
        QString name = QUrl(url).toString(QUrl::PreferLocalFile).replace("+", " ");
#endif
        p.save_path = (torrentPath + name + "/").toStdString();

        const torrent_handle h = libtorrent::add_magnet_uri(*session, torrentFile.toStdString(), p);
        main = new Torrent(torrentPath + QString::fromStdString(h.name()), mountPath + QString::fromStdString(h.name()), h, this);
    } else {
        torrent_info *inf = new libtorrent::torrent_info(torrentFile.toStdString());
        p.ti = inf;
        p.save_path = (torrentPath + QString::fromStdString(inf->name()) + "/").toStdString();
        main = new Torrent(torrentPath + QString::fromStdString(inf->name()), mountPath + QString::fromStdString(inf->name()), session->add_torrent(p), this);
    }

    setupTimers();
}
示例#12
0
	//----------------------------------------------------------------------
    System::System(RTPSSettings* set, CL* c)
    {
	dout<<"settings "<<set<<endl;

        settings = set;
        cli = c;
        acquiredGL=false;
        max_num = settings->GetSettingAs<unsigned int>("max_num_particles");
        num = settings->GetSettingAs<unsigned int>("num_particles");
        maxGravSources=settings->GetSettingAs<unsigned int>("max_gravity_sources");
        activeParticle = 0;
		// I should be able to not specify this, but GPU restrictions ...
        //seed random
        srand ( time(NULL) );

        grid = Domain(settings->GetSettingAs<float4>("domain_min"),settings->GetSettingAs<float4>("domain_max"));

        setupTimers();
        //*** end Initialization
#ifdef CPU
        dout<<"RUNNING ON THE CPU"<<endl;
#endif
#ifdef GPU
        dout<<"RUNNING ON THE GPU"<<endl;
        prepareSorted();

        //dout<<"Here"<<endl;
        //should be more cross platform
        string common_source_dir = settings->GetSettingAs<string>("rtps_path") + "/" + std::string(COMMON_CL_SOURCE_DIR);
        cli->addIncludeDir(common_source_dir);
        //dout<<common_source_dir.c_str()<<endl;

        hash = Hash(common_source_dir, cli, timers["hash_gpu"]);
        gravity = Gravity(common_source_dir, cli);
        bitonic = Bitonic<unsigned int>(common_source_dir, cli );
        //radix = Radix<unsigned int>(common_source_dir, cli, max_num, 128);
        cellindices = CellIndices(common_source_dir, cli, timers["ci_gpu"] );
        permute = Permute( common_source_dir, cli, timers["perm_gpu"] );
        m2p = MeshToParticles(common_source_dir, cli, timers["meshtoparticles_gpu"]);
        marchingcubes = MarchingCubes(common_source_dir, cli, timers["marchingcubes_gpu"],settings->GetSettingAs<unsigned int>("color_field_res","2"));
#endif

    }
示例#13
0
/*
 * @brief   stm32 board specific init
 * @param   none
 * @return  none
 * @note    none
 */
void stm32utils_system_init(void)
{
    setupFlash();
    setupClocks();
    setupNVIC();
    systick_init(SYSTICK_RELOAD_VAL);
    gpio_init_all();
    afio_init();
    setupADC();
    setupTimers();
    setupUSART(USARTx, SERIAL_BAUDRATE);

    gpio_set_mode(GPIOA, 0, GPIO_OUTPUT_PP);
    gpio_write_bit(GPIOA, 0, 0);
    gpio_set_mode(GPIOA, 1, GPIO_OUTPUT_PP);
    gpio_write_bit(GPIOA, 1, 0);
    gpio_set_mode(GPIOA, 12, GPIO_OUTPUT_PP);
    gpio_write_bit(GPIOA, 12, 0);
}
示例#14
0
    SSEffect::SSEffect(ShaderLibrary* lib, GLuint width, GLuint height)://, GLfloat pointRadius,bool blending):
        ParticleEffect(lib,width,height)//,pointRadius,blending)
    {
        //cout<<"Shaderlib size = "<<m_shaderLibrary.shaders.size()<<endl;
        m_fbos.resize(1);
        glGenFramebuffersEXT(1,&m_fbos[0]);
        createFramebufferTextures();
        currentDepthBuffer="depth";
        glEnable(GL_TEXTURE_2D);
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,m_fbos[0]);
        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["thickness1"],0);

        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT,GL_TEXTURE_2D,m_glFramebufferTexs["depth"],0);

        dout<<"fbo[0] = "<<m_fbos[0]<<" status complete? "<<((glCheckFramebufferStatus(GL_FRAMEBUFFER)==GL_FRAMEBUFFER_COMPLETE)?"yes":"no")<<" "<<glCheckFramebufferStatus(GL_FRAMEBUFFER)<<endl;
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,0);

        glDisable(GL_TEXTURE_2D);
        setupTimers();
    }
示例#15
0
//----------------------------------------------------------------------
FLOCK::FLOCK(RTPSSettings* set, CL* c):System(set,c)
{
    //seed random
    srand ( time(NULL) );

    std::vector<FLOCKParameters> vparams(0);
    vparams.push_back(flock_params);
    cl_FLOCKParameters= Buffer<FLOCKParameters>(cli, vparams);

    calculate();
    updateParams();

    spacing = settings->GetSettingAs<float>("spacing");
    dout<<"spacing ="<<spacing<<endl;

    //set up the grid
    setupDomain(flock_params.smoothing_distance/flock_params.simulation_scale,flock_params.simulation_scale);

    //set up the timers
    setupTimers();

    //setup the sorted and unsorted arrays
    prepareSorted();

#ifdef CPU
    dout<<"RUNNING ON THE CPU"<<endl;
#endif
#ifdef GPU
    dout<<"RUNNING ON THE GPU"<<endl;

    //should be more cross platform
    string flock_source_dir = settings->GetSettingAs<string>("rtps_path") + "/" + std::string(FLOCK_CL_SOURCE_DIR);

    cli->addIncludeDir(flock_source_dir);

    rules = Rules(flock_source_dir, cli, timers["rules_gpu"]);
    euler_integration = EulerIntegration(flock_source_dir, cli, timers["euler_gpu"]);
#endif
        //renderer->setParticleRadius(spacing);
}
示例#16
0
void init(void) {
    setupFlash();
    setupClocks();
    setupNVIC();
    systick_init(SYSTICK_RELOAD_VAL);
    gpio_init_all();
    afio_init();
    setupADC();
    setupTimers();
    setupUSB();
    boardInit();

    //for debug
    gpio_set_mode(GPIOA, 2, GPIO_AF_OUTPUT_PP);
 	gpio_set_mode(GPIOA, 3, GPIO_INPUT_FLOATING);


 	usart_init(USART2);
 	usart_set_baud_rate(USART2, STM32_PCLK1, 57600);
 	usart_enable(USART2);
 	/*delay(1000);
 	TxDString("hello pandora\r\n");*/
}
示例#17
0
文件: Query.c 项目: GregoryFaust/yaha
void * processQueries(void * QSptr)
{
    setupTimers();
    defineTimer(setupSecs);
    defineTimer(findDiagonals);
    defineTimer(findClumps);
    defineTimer(filterClumps);
    defineTimer(processClumps);
    defineTimer(printClumpss);
    defineTimer(totalTimer);

    // Use skipDist of 1 for query, regardless of what was used to create the hash table.
    int skipDist = 1;
    // Cache the wordLen on the stack to speed loop access.
    QueryState_t * QS = (QueryState_t *) QSptr;
    AlignmentArgs_t * AAs = QS->AAs;
    int wordLen = AAs->wordLen;
    int maxHits = AAs->maxHits;
    ROFF *startingOffs = AAs->startingOffs;

#ifdef STATS
    // Let's keep some statistics about the queries we process.
    int queryCount = 0;
    int totalQueryLength = 0;
    uint64_t totalTotalCount = 0;
    int minQLength = 1000000000;
    int maxQLength = 0;
    int minTotalCount = 1000000000;
    int maxTotalCount = 0;

    uint64_t totalClumpsOut = 0;
    int minClumpsPerQuery = 1000000000;
    int maxClumpsPerQuery = -1;
    int totalNonAlignedQueries = 0;
#endif

/////
//     Now we are ready to go into the main query read loop.
/////

    // Calculate some masks for use later.
    UINT hashMask = ((UINT)0xFFFFFFFF) >> (32 - 2*wordLen);
    int  hashSaveLength = wordLen - skipDist;

    startTime();

    // To get started, make sure we have read a first query.
    // This is a partial unwind of the first time through the loop.
    // It allows the main thread to read the first query to get a query length estimate to use to create the other threads.
    if (QS->queryLen == 0) readNextQuery(AAs, QS);

    while (QS->queryLen > 0)
    {
///////
//     First Phase.  Read in the query, reverse it, and do the initial hashing.
///////

        // See if we need to reallocate the query length dependent structures.
        if (QS->queryLen > QS->maxQueryLength) reallocNewMaxQueryLength(QS);

        QOFF qbaseCount = QS->queryLen;

#ifdef STATS
        fprintQueryId(QS, stderr);
#endif
#ifdef QUERYSTATS
        struct timeval starttime, endtime;
        if (AAs->queryStats)
        {
            QS->alignCount = 0;
            QS->alignOutCount = 0;
            QS->DPCount = 0;
            QS->usec = 0;
            QS->seedMatches = 0;
            QS->diagRegionCount = 0;
            QS->diagRegionTotal = 0;
            gettimeofday(&starttime, NULL);
        }
#endif

/////
//     Now match the query against both the reference DNA and its reverse-complement strand.
//     Therefore the bases in the reversed query are also complemented.
/////

        // Do the forward query first.
        int offsetCount = ((qbaseCount - wordLen)/skipDist) + 1;
        for (int rev=0; rev<=1; rev++)
        {
            QS->reversed = (BOOL)rev;

            if (QS->reversed)
            {
                QS->queryCodeBuf = QS->reverseCodeBuf;
                QS->queryBuf = QS->reverseBuf;
            }
            else
            {
                QS->queryCodeBuf = QS->forwardCodeBuf;
                QS->queryBuf = QS->forwardBuf;
            }

/////
//     Find the hash seeds, filter overhits, and fill in structures from the hash table.
/////

#ifdef STATS
            UINT maxHitsOverCount = 0;
#endif
            // The loop complication is because we want to both encode each base once, and skip over non-ACGT codes.
            UINT totalCount = 0;
            int baseOff = 0;
            int endingOffset = qbaseCount - wordLen;
            UINT hashCode = 0;
            UINT partialHashCode = 0;
            int badOffset = generateMatches4UNPto2Fast(QS->queryCodeBuf, baseOff, wordLen, &hashCode);
            while (TRUE)
            {
                if (badOffset != 0)
                {
                    // Get rid of all the bad ones in a row.
                    while (badOffset <= endingOffset && QS->queryCodeBuf[badOffset] > 3) badOffset += 1;
                    // Make sure the ones we skipped over have their count set to zero.
                    // We need to handle the case where the above has gone too far.
                    badOffset = MIN(badOffset, endingOffset + 1);
                    // fprintf(stderr, "After throwing away bases, badOffset %d baseOff %d endingOffset %d \n", badOffset, baseOff, endingOffset);
                    for (int i=baseOff; i<badOffset; i++) QS->offsetCounts[i].count = 0;
                    // Move forward on the query.
                    baseOff = badOffset;
                    if (baseOff > endingOffset) break;
                    // Try to load entire word.
                    badOffset = generateMatches4UNPto2Fast(QS->queryCodeBuf, baseOff, wordLen, &hashCode);
                    continue;
                }
                // The previous read was good, so process it.
                // Max out before we overflow.
                UINT count = startingOffs[hashCode+1] - startingOffs[hashCode];
                if (count <= maxHits)
                {
                    totalCount += count;
                    QS->offsetCounts[baseOff].count = count;
                    QS->offsetCounts[baseOff].sOffset = startingOffs[hashCode];
                    QS->offsetCounts[baseOff].newCount = 0;
                }
                else
                {
#ifdef STATS
                    maxHitsOverCount += 1;
#endif
                    QS->offsetCounts[baseOff].count = 0;
                }
                // and just get the next skipDist worth
                baseOff += 1;
                if (baseOff > endingOffset) break;
                badOffset = generateMatches4UNPto2Fast(QS->queryCodeBuf, baseOff + hashSaveLength, 1, &partialHashCode);
                // and tack it on to the rest from the previous get.
                hashCode = ((hashCode << 2) | partialHashCode) & hashMask;
            }

#ifdef STATS
            fprintf(stderr, "K-mers above maxHits %u\n", maxHitsOverCount);
            totalTotalCount += totalCount;
            if (totalCount > 0 && totalCount < minTotalCount) minTotalCount = totalCount;
            if (totalCount > maxTotalCount) maxTotalCount = totalCount;
#endif
#ifdef QUERYSTATS
            if (AAs->queryStats)QS->seedMatches += totalCount;
#endif
            addToTimer(setupSecs);

            // If the totalCount is zero, we have no hits to process.
            if (totalCount == 0) continue;

/////
//     Second Phase.  Go through all hash matches, and look for diagonal fragments.
/////

            int fragCount = findFragmentsSort(AAs, QS, offsetCount);
            addToTimer(findDiagonals);

/////
//     Third Phase.  Put Fragments into potential alignments (clumps).
/////

            processFragmentsGapped(AAs, QS, fragCount);
            addToTimer(findClumps);

        }

        // Align and Score clumps, filtering those that don't meet thresholds.
        postProcessClumps(QS, AAs);
        addToTimer(processClumps);

        // Run OQC algorithm if requested.
        // If not, at least get rid of duplicates.
        if   (AAs->OQC) postFilterBySimilarity(AAs, QS);
        else            postFilterRemoveDups(AAs, QS);
        addToTimer(filterClumps);

        // The file lock and unlock here act as the thread synchromization mechanism.
        // This will ensure that all alignments for a given query are in contiguous lines in the output file.
        // Otherwise, many downstream tools such as samtools will be unhappy.
        flockfile(AAs->outFile);

        // This is to avoid compiler warning when STATS not on.
#ifdef STATS
        int tempClumpsPerQuery = printClumps(QS, AAs);
#else
        printClumps(QS, AAs);
#endif

        funlockfile(AAs->outFile);
        addToTimer(printClumpss);

#ifdef STATS
        queryCount += 1;
        totalQueryLength += qbaseCount;
        if (qbaseCount < minQLength) minQLength = qbaseCount;
        if (qbaseCount > maxQLength) maxQLength = qbaseCount;
        totalClumpsOut += tempClumpsPerQuery;
        if (tempClumpsPerQuery > maxClumpsPerQuery) maxClumpsPerQuery = tempClumpsPerQuery;
        if (tempClumpsPerQuery > 0 && tempClumpsPerQuery < minClumpsPerQuery) minClumpsPerQuery = tempClumpsPerQuery;
        if (tempClumpsPerQuery == 0) totalNonAlignedQueries += 1;
#endif

#ifdef QUERYSTATS
        if (AAs->queryStats)
        {
            gettimeofday(&endtime, NULL);
            QS->usec = ((endtime.tv_sec - starttime.tv_sec) * 1000000 +
                        (endtime.tv_usec - starttime.tv_usec));
            printChars(AAs->qsFile, QS->queryID, 0, QS->queryIDLen);
            double avgDiagRegionSize = (QS->diagRegionCount > 0) ? (((double)QS->diagRegionTotal/(double)QS->diagRegionCount)+0.0) : 0;
            fprintf(AAs->qsFile, "\t%u\t%u\t%f\t%u\t%u\t%u\t%u\n", QS->queryLen, QS->seedMatches, avgDiagRegionSize,
                    QS->alignCount, QS->DPCount, QS->alignOutCount, QS->usec);
        }
#endif

        // Clear query state to get ready for next query.
        resetQueryState(QS);
        // Read the next query to setup for next iteration.
        readNextQuery(AAs, QS);
    }

//////////////////////
//    Done with processing the query file.
//    Close files and clean up storage.
/////////////////////

#ifdef TIMING
    addToTimer(setupSecs);
    endTime(totalTimer);

    flockfile(stderr);
    // if (AAs->threadCount > 1) fprintf(stderr, "Thread %d statistics.\n", QS->threadNum);
    fprintTimerWithTotalPercent(stderr, "Query setup and hashing took: ", setupSecs, totalTimer);
    fprintTimerWithTotalPercent(stderr, "Sorting k-mers and forming fragments took: ", findDiagonals, totalTimer);
    fprintTimerWithTotalPercent(stderr, "Collecting fragments into clumps (using graph) took: ", findClumps, totalTimer);
    fprintTimerWithTotalPercent(stderr, "Aligning and scoring clumps took: ", processClumps, totalTimer);
    fprintTimerWithTotalPercent(stderr, "Filtering clumps took: ", filterClumps, totalTimer);
    fprintTimerWithTotalPercent(stderr, "Printing clumps took: ", printClumpss, totalTimer);
    funlockfile(stderr);
#endif

#ifdef STATS
    if (AAs->verbose)
    {
        fprintf(stderr, "%d queries processed.\n", queryCount);
        fprintf(stderr, "Query Lengths vary from %d to %d with average %d.\n",
                minQLength, maxQLength, (totalQueryLength/queryCount));
        fprintf(stderr, "Total Counts vary from %d to %d with average %"PRIu64".\n",
                minTotalCount, maxTotalCount, (totalTotalCount/(2 * queryCount)));
        fprintf(stderr, "There were %d queries with no Alignment.\n", totalNonAlignedQueries);
        if (totalClumpsOut <= 0) fprintf(stderr, "No Alignments found.\n");
        else
        {
            fprintf(stderr, "Total Alignments Output = %"PRIu64", average %4.2f per non-zero query.\n", totalClumpsOut,
                    ((double)totalClumpsOut/(queryCount-totalNonAlignedQueries)));
            fprintf(stderr, "Of those queries with an alignment, the min number of alignments was %d.\n", minClumpsPerQuery);
            fprintf(stderr, "The max number of alignments per query was %d.\n", maxClumpsPerQuery);
        }
    }
#endif

    // Deallocate thread local structures.
    finalizeQueries(QS);
    disposeQueryState(QS);
    return NULL;
}
示例#18
0
文件: robot.c 项目: DCLMonk/Omnibot
int main(int argc, char* argv[]) {

    DDRC = 0x0f;
    DDRD = 0xf0;
    DDRB = 0xC3;
    PORTB = 0;
    PORTC = 0;
    PORTD = 0;
    serial_init();
    send_string_serial("Starting up...\n");
    _delay_ms(500);

    speed1 = 4000;
    speed2 = 4000;
    speed3 = 4000;
    speed4 = 1250;
    counter1 = 1;
    counter2 = 1;
    counter3 = 1;
    counter4 = 1;

    needState1 = FALSE;
    needState2 = FALSE;
    needState3 = FALSE;

    movingForward1 = FALSE;
    movingForward2 = FALSE;
    movingForward3 = FALSE;

    currentState1 = 0;
    currentState2 = 0;
    currentState3 = 0;

    motorState1 = getMotorState(currentState1);
    motorState2 = getMotorState(currentState2) << 4;
    unsigned char state = getMotorState(currentState3);
    motorState3 = ((state & 0x0C) << 4) | (state & 0x03);

    setupTimers();

	char index = 0;
	int speeds[3];
	char* buffer = (char*) speeds;

    while (1) {
		if  (UCSRA & (1<<RXC)) {
			buffer[index++] = UDR;
			
			if (index == 6) {
				// do something with the buffer
				setSpeed1(speeds[0]);
				setSpeed2(speeds[1]);
				setSpeed3(speeds[2]);
				index = 0;
				send_string_serial("Received full message\n\r");
			}
		}

        checkSerialSend();
        if (needState1) {
            currentState1 = getNextState(currentState1, movingForward1);
            motorState1 = getMotorState(currentState1);
            needState1 = FALSE;
        }
        if (needState2) {
            currentState2 = getNextState(currentState2, movingForward2);
            motorState2 = getMotorState(currentState2) << 4;
            needState2 = FALSE;
        }
        if (needState3) {
            currentState3 = getNextState(currentState3, movingForward3);
            state = getMotorState(currentState3);
            motorState3 = ((state & 0x0C) << 4) | (state & 0x03);
            needState3 = FALSE;
        }
/*
        if (needsNewSpeed) {
            currentSpeedIndex = (currentSpeedIndex + 1);
            if (currentSpeedIndex == 0x40) {
                currentSpeedIndex = 0;
                send_string_serial("Loop...\n");
            }
            setSpeed1(speed[0][currentSpeedIndex]);
            setSpeed2(speed[1][currentSpeedIndex]);
            setSpeed3(speed[2][currentSpeedIndex]);
            needsNewSpeed = FALSE;
        }
*/
    }

	return 0;
}
示例#19
0
Common::Error KyraEngine_v1::init() {
	// Setup mixer
	syncSoundSettings();

	if (!_flags.useDigSound) {
		if (_flags.platform == Common::kPlatformFMTowns) {
			if (_flags.gameID == GI_KYRA1)
				_sound = new SoundTowns(this, _mixer);
			else
				_sound = new SoundTownsPC98_v2(this, _mixer);
		} else if (_flags.platform == Common::kPlatformPC98) {
			if (_flags.gameID == GI_KYRA1)
				_sound = new SoundPC98(this, _mixer);
			else
				_sound = new SoundTownsPC98_v2(this, _mixer);
		} else if (_flags.platform == Common::kPlatformAmiga) {
			_sound = new SoundAmiga(this, _mixer);
		} else {
			// In Kyra 1 users who have specified a default MT-32 device in the launcher settings
			// will get MT-32 music, otherwise AdLib. In Kyra 2 and LoL users who have specified a
			// default GM device in the launcher will get GM music, otherwise AdLib. Users who want
			// MT-32 music in Kyra2 or LoL have to select this individually (since we assume that
			// most users rather have a GM device than a MT-32 device).
			// Users who want PC speaker sound always have to select this individually for all
			// Kyra games.
			MidiDriver::DeviceHandle dev = MidiDriver::detectDevice(MDT_PCSPK | MDT_MIDI | MDT_ADLIB | ((_flags.gameID == GI_KYRA2 || _flags.gameID == GI_LOL) ? MDT_PREFER_GM : MDT_PREFER_MT32));
			if (MidiDriver::getMusicType(dev) == MT_ADLIB) {
				_sound = new SoundAdLibPC(this, _mixer);
			} else {
				Sound::kType type;
				const MusicType midiType = MidiDriver::getMusicType(dev);

				if (midiType == MT_PCSPK || midiType == MT_NULL)
					type = Sound::kPCSpkr;
				else if (midiType == MT_MT32 || ConfMan.getBool("native_mt32"))
					type = Sound::kMidiMT32;
				else
					type = Sound::kMidiGM;

				MidiDriver *driver = 0;

				if (MidiDriver::getMusicType(dev) == MT_PCSPK) {
					driver = new MidiDriver_PCSpeaker(_mixer);
				} else {
					driver = MidiDriver::createMidi(dev);
					if (type == Sound::kMidiMT32)
						driver->property(MidiDriver::PROP_CHANNEL_MASK, 0x03FE);
				}

				assert(driver);

				SoundMidiPC *soundMidiPc = new SoundMidiPC(this, _mixer, driver, type);
				_sound = soundMidiPc;
				assert(_sound);

				// Unlike some SCUMM games, it's not that the MIDI sounds are
				// missing. It's just that at least at the time of writing they
				// are decidedly inferior to the AdLib ones.
				if (ConfMan.getBool("multi_midi")) {
					SoundAdLibPC *adlib = new SoundAdLibPC(this, _mixer);
					assert(adlib);

					_sound = new MixedSoundDriver(this, _mixer, soundMidiPc, adlib);
				}
			}
		}

		assert(_sound);
	}

	if (_sound)
		_sound->updateVolumeSettings();

	_res = new Resource(this);
	assert(_res);
	_res->reset();

	if (_flags.isDemo) {
		// HACK: check whether this is the HOF demo or the LOL demo.
		// The LOL demo needs to be detected and run as KyraEngine_HoF,
		// but the static resource loader and the sequence player will
		// need correct IDs.
		if (_res->exists("scene1.cps"))
#ifdef ENABLE_LOL
			_flags.gameID = GI_LOL;
#else
			error("Lands of Lore demo is not supported in this build");
#endif // !ENABLE_LOL
	}

	_staticres = new StaticResource(this);
	assert(_staticres);
	if (!_staticres->init())
		error("_staticres->init() failed");
	if (!screen()->init())
		error("screen()->init() failed");
	_timer = new TimerManager(this, _system);
	assert(_timer);
	setupTimers();
	_emc = new EMCInterpreter(this);
	assert(_emc);

	setupOpcodeTable();
	readSettings();

	if (ConfMan.hasKey("save_slot")) {
		_gameToLoad = ConfMan.getInt("save_slot");
		if (!saveFileLoadable(_gameToLoad))
			_gameToLoad = -1;
	}

	setupKeyMap();

	// Prevent autosave on game startup
	_lastAutosave = _system->getMillis();

	return Common::kNoError;
}
示例#20
0
// short_init is used by safecast to do a quick power-on
// it's special cased to shorten the "ON" duty-cycle
void short_init(void) {
    setupFlash();
    setupClocks();
    setupNVIC();
    setupTimers();
}
示例#21
0
// Read the file and add settings to the settings map
ProjectSettings::ProjectSettings(const std::string filename)
{
    setupTimers();
    this->ParseFile(filename);
}
示例#22
0
/******************************************************************
 * 			Main-function
 */
int main(void) {

	/**************************************
	 * 	Set the clock to run at 80 MHz
	 */
	SysCtlClockSet(SYSCTL_SYSDIV_2_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN);

	/**************************************
	 * 	Enable the floating-point-unit
	 */
	FPUEnable();
	// We also want Lazystacking, so enable that too
	FPULazyStackingEnable();
	// We also want to put numbers close to zero to zero
	FPUFlushToZeroModeSet(FPU_FLUSH_TO_ZERO_EN);

	/**************************************
	 * 	Init variables
	 */
	uint16_t mapData[MAP_DATA_SIZE];
	uint8_t stepDir = 0;

	/**************************************
	 * 	Init peripherals used
	 */
	bluetooth_init();
	init_stepper();							// Init the GPIOs used for the stepper and loading LED
	InitI2C1();								// Init the communication with the lidar-unit through I2C
	InitPWM();
	setupTimers();

	/**************************************
	 * 	State 2
	 */
	// Disable the timers that are used
	disableTimer(TIMER1_BASE);
	disableTimer(TIMER2_BASE);

	// Enable all interrupts
	IntMasterEnable();
	/**************************************
	 * 	State 3
	 */
	// Indicate we should start with a scan regardless of what other things we have already got
	// from UART-interrupt
	// This means setting the appropriate bit in the status vector
	stat_vec |= TAKE_MEAS;

	/**************************************
	 * 	State 4
	 */
	// Contains main-loop where decisions should be made
	for ( ; ; ) {
		/**********************************
		 * 	Decision tree
		 */
		// Highest priority case first


		// Check both interrupts at each iteration in the loop
		if ( int_vec & UART_INT ) {
			// Reset the indication
			int_vec &= ~UART_INT;

			// Remove drive-stop flag to enable movement
			stat_vec &= ~DRIVE_STOP;

			// Init data array
			uint8_t dataArr[MAX_UART_MSG_SIZE];

			// Collect the message
			if ( readUARTMessage(dataArr, MAX_UART_MSG_SIZE) < SUCCESS ) {
				// If we have recieved more data than fits in the vector we should simply
				// go in here again and grab data
				int_vec |= UART_INT;
			}
			// We have gathered a message
			// and now need to determine what the message is
			parseMsg(dataArr, MAX_UART_MSG_SIZE);
		}
		// Checking drive (movement) interrupt
		if ( int_vec & TIMER2_INT ) {
			int_vec &= ~TIMER2_INT;
			// Disable TIMER2
			disableTimer(TIMER2_BASE);
			// Set drive-stop in status vector
			stat_vec |= DRIVE_STOP;
		}
		// Checking measure interrupt
		if ( int_vec & TIMER1_INT ) {
			int_vec &= ~TIMER1_INT;
			// Disable TIMER1
			disableTimer(TIMER1_BASE);

			// Take reading from LIDAR
			mapData[stepCount++] = readLidar();
			SysCtlDelay(2000);

			// Take step
			// Note: We need to take double meas at randvillkor (100) !!!!!
			if ( stepCount > 0 && stepCount < 100 ) {
				stepDir = 1;
			}
			else if ( stepCount >= 100 && stepCount < 200) {
				stepDir = 0;
			}
			else {
				stepDir = 1;
				stepCount = 0;

				// Reset busy-flag
				stat_vec &= ~TAKE_MEAS;
			}
			step = takeStep(step, stepDir);

			// Request reading from LIDAR
			reqLidarMeas();

			if ( stat_vec & TAKE_MEAS ) {
				// Restart TIMER1
				enableTimer(TIMER1_BASE, (SYSCLOCK / MEASUREMENT_DELAY));
			}
			else {
				sendUARTDataVector(mapData, MAP_DATA_SIZE);
				stat_vec &= ~BUSY;
			}
		}

		// Check the drive_stop flag, which always should be set unless we should move
		if ( stat_vec & DRIVE_STOP ) {
			// Stop all movement
			SetPWMLevel(0,0);
			halt();

			// MAKE SURE all drive-flags are not set
			stat_vec &= ~(DRIVE_F | DRIVE_L | DRIVE_R | DRIVE_LL | BUSY);
		}
		// Should we drive?
		else if ( stat_vec & DRIVE ) {
			// Remove drive flag
			stat_vec &= ~DRIVE;
			// Increase PWM
			increase_PWM(0,MAX_FORWARD_SPEED,0,MAX_FORWARD_SPEED);
			if ( stat_vec & DRIVE_F ) {
				enableTimer(TIMER2_BASE, DRIVE_FORWARD_TIME);
			}
			else if ( stat_vec & DRIVE_LL ) {
				enableTimer(TIMER2_BASE, DRIVE_TURN_180_TIME);
			}
			else {
				enableTimer(TIMER2_BASE, DRIVE_TURN_TIME);
			}
		}
		if ( !(stat_vec & BUSY) ) {
			// Tasks
			switch ( stat_vec ) {
				case ((uint8_t)DRIVE_F) :
					// Call drive function
					go_forward();
					// Set the drive flag & BUSY
					stat_vec |= DRIVE | BUSY;
					break;
				case ((uint8_t)DRIVE_L) :
					// Call drive-left function
					go_left();
					// Set the drive flag
					stat_vec |= DRIVE | BUSY;
					break;
				case ((uint8_t)DRIVE_R) :
					// Call drive-right function
					go_right();
					// Set the drive flag
					stat_vec |= DRIVE | BUSY;
					break;
				case ((uint8_t)DRIVE_LL) :
					// Call turn 180-degrees function
					go_back();
					// Set the drive flag
					stat_vec |= DRIVE | BUSY;
					break;
				case ((uint8_t)TAKE_MEAS) :
					// Request reading from LIDAR
					reqLidarMeas();
					// Start TIMER1
					enableTimer(TIMER1_BASE, (SYSCLOCK / MEASUREMENT_DELAY)); // if sysclock = 1 s, 1/120 = 8.3 ms
					// We are busy
					stat_vec |= BUSY;
					break;

				default:
					break;
			}
		}
	}
}