/*
ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "ch.h"
#include "hal.h"
#include "test.h"
/*
* This is a periodic thread that does absolutely nothing except flashing LEDs.
*/
static WORKING_AREA(waThread1, 128);
static msg_t Thread1(void *arg) {
(void)arg;
chRegSetThreadName("blinker");
while (TRUE) {
palClearPad(GPIOC, GPIOC_LED1);
chThdSleepMilliseconds(250);
palSetPad(GPIOC, GPIOC_LED1);
palClearPad(GPIOC, GPIOC_LED2);
chThdSleepMilliseconds(250);
palSetPad(GPIOC, GPIOC_LED2);
palClearPad(GPIOC, GPIOC_LED3);
chThdSleepMilliseconds(250);
palSetPad(GPIOC, GPIOC_LED3);
palClearPad(GPIOC, GPIOC_LED4);
chThdSleepMilliseconds(250);
palSetPad(GPIOC, GPIOC_LED4);
}
}
/*
* Application entry point.
*/
int main(void) {
/*
* System initializations.
* - HAL initialization, this also initializes the configured device drivers
* and performs the board-specific initializations.
* - Kernel initialization, the main() function becomes a thread and the
* RTOS is active.
*/
halInit();
chSysInit();
/*
* Activates the serial driver 2 using the default configuration, pins
* are pre-configured in board.h.
*/
sdStart(&SD2, NULL);
/*
* Creates the example thread.
*/
chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
/*
* Normal main() thread activity, in this demo it does nothing except
* sleeping in a loop and check the button state, when the button is
* pressed the test procedure is launched.
*/
while (TRUE) {
if (palReadPadpre { line-height: 125%; margin: 0; }
td.linenos pre { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
span.linenos { color: #000000; background-color: #f0f0f0; padding: 0 5px 0 5px; }
td.linenos pre.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
span.linenos.special { color: #000000; background-color: #ffffc0; padding: 0 5px 0 5px; }
.highlight .hll { background-color: #ffffcc }
.highlight { background: #ffffff; }
.highlight .c { color: #888888 } /* Comment */
.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
.highlight .k { color: #008800; font-weight: bold } /* Keyword */
.highlight .ch { color: #888888 } /* Comment.Hashbang */
.highlight .cm { color: #888888 } /* Comment.Multiline */
.highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */
.highlight .cpf { color: #888888 } /* Comment.PreprocFile */
.highlight .c1 { color: #888888 } /* Comment.Single */
.highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */
.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
.highlight .ge { font-style: italic } /* Generic.Emph */
.highlight .gr { color: #aa0000 } /* Generic.Error */
.highlight .gh { color: #333333 } /* Generic.Heading */
.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
.highlight .go { color: #888888 } /* Generic.Output */
.highlight .gp { color: #555555 } /* Generic.Prompt */
.highlight .gs { font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #666666 } /* Generic.Subheading */
.highlight .gt { color: #aa0000 } /* Generic.Traceback */
.highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #008800 } /* Keyword.Pseudo */
.highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */
.highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */
.highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */
.highlight .na { color: #336699 } /* Name.Attribute */
.highlight .nb { color: #003388 } /* Name.Builtin */
.highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */
.highlight .no { color: #003366; font-weight: bold } /* Name.Constant */
.highlight .nd { color: #555555 } /* Name.Decorator */
.highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */
.highlight .nl { color: #336699; font-style: italic } /* Name.Label */
.highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */
.highlight .py { color: #336699; font-weight: bold } /* Name.Property */
.highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #336699 } /* Name.Variable */
.highlight .ow { color: #008800 } /* Operator.Word */
.highlight .w { color: #bbbbbb } /* Text.Whitespace */
.highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */
.highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */
.highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */
.highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */
.highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */
.highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */
.highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */
.highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */
.highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */
.highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */
.highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */
.highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */
.highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */
.highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */
.highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */
.highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */
.highlight .vc { color: #336699 } /* Name.Variable.Class */
.highlight .vg { color: #dd7700 } /* Name.Variable.Global */
.highlight .vi { color: #3333bb } /* Name.Variable.Instance */
.highlight .vm { color: #336699 } /* Name.Variable.Magic */
.highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long *//**CFile****************************************************************
FileName [extraUtilBitMatrix.c]
PackageName [extra]
Synopsis [Various reusable software utilities.]
Author [Alan Mishchenko]
Affiliation [UC Berkeley]
Date [Ver. 1.0. Started - September 1, 2003.]
Revision [$Id: extraUtilBitMatrix.c,v 1.0 2003/09/01 00:00:00 alanmi Exp $]
***********************************************************************/
#include "extra.h"
ABC_NAMESPACE_IMPL_START
/*---------------------------------------------------------------------------*/
/* Constant declarations */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* Stucture declarations */
/*---------------------------------------------------------------------------*/
struct Extra_BitMat_t_
{
unsigned ** ppData; // bit data
int nSize; // the number of bits in one dimension
int nWords; // the number of words in one dimension
int nBitShift; // the number of bits to shift to get words
unsigned uMask; // the mask to get the number of bits in the word
int nLookups; // the number of lookups
int nInserts; // the number of inserts
int nDeletes; // the number of deletions
};
/*---------------------------------------------------------------------------*/
/* Type declarations */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* Variable declarations */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* Macro declarations */
/*---------------------------------------------------------------------------*/
/**AutomaticStart*************************************************************/
/*---------------------------------------------------------------------------*/
/* Static function prototypes */
/*---------------------------------------------------------------------------*/
/**AutomaticEnd***************************************************************/
/*---------------------------------------------------------------------------*/
/* Definition of exported functions */
/*---------------------------------------------------------------------------*/
/**Function*************************************************************
Synopsis [Starts the bit matrix.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Extra_BitMat_t * Extra_BitMatrixStart( int nSize )
{
Extra_BitMat_t * p;
int i;
p = ABC_ALLOC( Extra_BitMat_t, 1 );
memset( p, 0, sizeof(Extra_BitMat_t) );
p->nSize = nSize;
p->nBitShift = (sizeof(unsigned) == 4) ? 5: 6;
p->uMask = (sizeof(unsigned) == 4) ? 31: 63;
p->nWords = nSize / (8 * sizeof(unsigned)) + ((nSize % (8 * sizeof(unsigned))) > 0);
p->ppData = ABC_ALLOC( unsigned *, nSize );
p->ppData[0] = ABC_ALLOC( unsigned, nSize * p->nWords );
memset( p->ppData[0], 0, sizeof(unsigned) * nSize * p->nWords );
for ( i = 1; i < nSize; i++ )
p->ppData[i] = p->ppData[i-1] + p->nWords;
return p;
}
/**Function*************************************************************
Synopsis [Stops the bit matrix.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixClean( Extra_BitMat_t * p )
{
memset( p->ppData[0], 0, sizeof(unsigned) * p->nSize * p->nWords );
}
/**Function*************************************************************
Synopsis [Stops the bit matrix.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixStop( Extra_BitMat_t * p )
{
ABC_FREE( p->ppData[0] );
ABC_FREE( p->ppData );
ABC_FREE( p );
}
/**Function*************************************************************
Synopsis [Prints the bit-matrix.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixPrint( Extra_BitMat_t * pMat )
{
int i, k, nVars;
printf( "\n" );
nVars = Extra_BitMatrixReadSize( pMat );
for ( i = 0; i < nVars; i++ )
{
for ( k = 0; k <= i; k++ )
printf( " " );
for ( k = i+1; k < nVars; k++ )
if ( Extra_BitMatrixLookup1( pMat, i, k ) )
printf( "1" );
else
printf( "." );
printf( "\n" );
}
}
/**Function*************************************************************
Synopsis [Reads the matrix size.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Extra_BitMatrixReadSize( Extra_BitMat_t * p )
{
return p->nSize;
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixInsert1( Extra_BitMat_t * p, int i, int k )
{
p->nInserts++;
if ( i < k )
p->ppData[i][k>>p->nBitShift] |= (1<<(k & p->uMask));
else
p->ppData[k][i>>p->nBitShift] |= (1<<(i & p->uMask));
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Extra_BitMatrixLookup1( Extra_BitMat_t * p, int i, int k )
{
p->nLookups++;
if ( i < k )
return ((p->ppData[i][k>>p->nBitShift] & (1<<(k & p->uMask))) > 0);
else
return ((p->ppData[k][i>>p->nBitShift] & (1<<(i & p->uMask))) > 0);
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixDelete1( Extra_BitMat_t * p, int i, int k )
{
p->nDeletes++;
if ( i < k )
p->ppData[i][k>>p->nBitShift] &= ~(1<<(k & p->uMask));
else
p->ppData[k][i>>p->nBitShift] &= ~(1<<(i & p->uMask));
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixInsert2( Extra_BitMat_t * p, int i, int k )
{
p->nInserts++;
if ( i > k )
p->ppData[i][k>>p->nBitShift] |= (1<<(k & p->uMask));
else
p->ppData[k][i>>p->nBitShift] |= (1<<(i & p->uMask));
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Extra_BitMatrixLookup2( Extra_BitMat_t * p, int i, int k )
{
p->nLookups++;
if ( i > k )
return ((p->ppData[i][k>>p->nBitShift] & (1<<(k & p->uMask))) > 0);
else
return ((p->ppData[k][i>>p->nBitShift] & (1<<(i & p->uMask))) > 0);
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixDelete2( Extra_BitMat_t * p, int i, int k )
{
p->nDeletes++;
if ( i > k )
p->ppData[i][k>>p->nBitShift] &= ~(1<<(k & p->uMask));
else
p->ppData[k][i>>p->nBitShift] &= ~(1<<(i & p->uMask));
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixOr( Extra_BitMat_t * p, int i, unsigned * pInfo )
{
int w;
for ( w = 0; w < p->nWords; w++ )
p->ppData[i][w] |= pInfo[w];
}
/**Function*************************************************************
Synopsis [Inserts the element into the upper part.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Extra_BitMatrixOrTwo( Extra_BitMat_t * p, int i, int j )
{
int w;
for ( w = 0; w < p->nWords; w++ )
p->ppData[i][w] = p->ppData[j][w] = (p->ppData[i][w] | p->ppData[j][w]);
}
/**Function*************************************************************
Synopsis [Counts the number of 1's in the upper rectangle.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Extra_BitMatrixCountOnesUpper( Extra_BitMat_t * p )
{
int i, k, nTotal = 0;
for ( i = 0; i < p->nSize; i++ )
for ( k = i + 1; k < p->nSize; k++ )
nTotal += ( (p->ppData[i][k>>5] & (1 << (k&31))) > 0 );
return nTotal;
}
/**Function*************************************************************
Synopsis [Returns 1 if the matrices have no entries in common.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Extra_BitMatrixIsDisjoint( Extra_BitMat_t * p1, Extra_BitMat_t * p2 )
{
int i, w;
assert( p1->nSize == p2->nSize );
for ( i = 0; i < p1->nSize; i++ )
for ( w = 0; w < p1->nWords; w++ )
if ( p1->ppData[i][w] & p2->ppData[i][w] )
return 0;
return 1;
}
/**Function*************************************************************
Synopsis [Returns 1 if the matrix is a set of cliques.]
Description [For example pairwise symmetry info should satisfy this property.]
SideEffects []
SeeAlso []
***********************************************************************/
int Extra_BitMatrixIsClique( Extra_BitMat_t * pMat )
{
int v, u, i;
for ( v = 0; v < pMat->nSize; v++ )
for ( u = v+1; u < pMat->nSize; u++ )
{
if ( !Extra_BitMatrixLookup1( pMat, v, u ) )
continue;
// v and u are symmetric
for ( i = 0; i < pMat->nSize; i++ )
{
if ( i == v || i == u )
continue;
// i is neither v nor u
// the symmetry status of i is the same w.r.t. to v and u
if ( Extra_BitMatrixLookup1( pMat, i, v ) != Extra_BitMatrixLookup1( pMat, i, u ) )
return 0;
}
}
return 1;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
ABC_NAMESPACE_IMPL_END
