/* main ===================================================================== */
int
main (void) {
xICounter xMyMeter;
xICounter * fm = &xMyMeter;
vLedInit ();
ATOMIC_BLOCK (ATOMIC_FORCEON) {
vSerialInit (TEST_BAUDRATE / 100, TEST_SETUP);
stdout = &xSerialPort;
vICounterInit (fm, TEST_INT);
vICounterSetWindow (fm, 1000);
}
printf ("Frequency Meter Test\nWindow=%u ms\n", fm->usWindow);
for (;;) {
if (bICounterIsComplete (fm)) {
dFreq = dICounterFreq (fm);
printf ("%.1f\n", dFreq);
delay_ms (100);
vICounterStart (fm);
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
vLedInit ();
#if defined(AVRIO_DEBUG_STREAM)
/* Init terminal */
vSerialInit (TEST_BAUDRATE / 100, SERIAL_DEFAULT + SERIAL_WR);
stderr = &xSerialPort;
fputc('\r', stderr);
#endif
vTwiInit ();
vAssert(eTwiSetSpeed (400) == TWI_SUCCESS);
vAssert(iWHubInit (WDEV_RATE_16KBPS, FRAM_SIZE, &xFRAM) == 0);
vWHubSetStatusFlag (WHUB_AUTOBIND, false);
// vWSdBaseClear ();
for (;;) {
vLedSet (LOOP_LED);
pxMsg = pxWHubLoop ();
vLedClear (LOOP_LED);
}
return 0;
}
/* internal public functions ================================================ */
int
main (void) {
eWNetErrorCode eError;
vLedInit ();
prvvDbgInit ();
vAssert (iWNetTestSetup () == 0);
(void) xWNetSetChannel (WNET_BIND_CHANNEL);
(void) xWNetSetPnCode (WNET_BIND_PNCODE);
vWNetSetCrcSeed (WPKT_BIND_CRC_SEED);
vWNetSetChecksumSeed (WPKT_BIND_CHECKSUM_SEED);
do {
eError = eWNetTestSensorBind (10, 100, &xTestResult);
prvvPrintResult (&xTestResult);
} while (eError < 0);
for (;;) {
eError = eWNetTestSensorPing (1000, 10, &xTestResult);
prvvPrintResult (&xTestResult);
vLedToggle (TEST_LED);
}
return 0;
}
void __attribute__((noreturn)) mainloop (void)
{
prvSetupHardware ();
vLedInit ();
/* If no previous environment exists - create a new, but don't store it */
env_init ();
if(!env_load ()) {
debug_printf ("unable to load environment, resetting to defaults\n");
bzero (&env, sizeof (env));
}
if (env.e.n_lamps > MAX_LAMPS)
env.e.n_lamps = 0;
vRndInit ((((u_int32_t) env.e.mac_h) << 8) | env.e.mac_l);
vNetworkInit ();
xTaskCreate (vUSBCDCTask, (signed portCHAR *) "USB", TASK_USB_STACK,
NULL, TASK_USB_PRIORITY, NULL);
PtInitProtocol ();
vUSBShellInit ();
vTaskStartScheduler ();
while(1);
}
/* main ===================================================================== */
int
main (void) {
xCounter xMyMeter;
xCounter * fm = &xMyMeter;
xCounterOps ops = {
.init = vTimerInit,
.clear = vTimerClear,
.enable = vTimerEnable,
.read = usTimerRead
};
vLedInit ();
ATOMIC_BLOCK (ATOMIC_FORCEON) {
vSerialInit (TEST_BAUDRATE / 100, TEST_SETUP);
stdout = &xSerialPort;
vCounterInit (fm, &ops);
vCounterSetWindow (fm, 100);
}
printf ("Frequency Meter Test\nWindow=%u ms\nCount,Freq\n", fm->usWindow);
for (;;) {
if (bCounterIsComplete (fm)) {
dFreq = dCounterFreq (fm);
printf ("%u,%.1f\n", usCounterCount(fm), dFreq);
delay_ms (100);
vCounterStart (fm);
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
static volatile int i;
vLedInit();
FILE * tc = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
stdout = tc;
stderr = tc;
stdin = tc;
sei();
for (;;) {
test_count = 1;
printf_P (PSTR ("\nAvrIO Log test\n"
"Press any key to proceed...\n"));
while (getchar() == EOF)
;
vLogSetMask (LOG_UPTO (LOG_INFO));
i = iLogMask();
test (i == LOG_UPTO (LOG_INFO));
vLog_P (LOG_INFO, flashstr, ++test_count);
vLog (LOG_INFO, ramstr, ++test_count);
for (i = LOG_DEBUG; i >= LOG_EMERG; i--) {
fprintf_P (stderr, PSTR ("\nPriority up to %s\n"), sLogPriorityString(i));
vLogSetMask (LOG_UPTO (i));
vLedSet (LED_LED1);
PERROR ("Error %d", test_count++);
vLedClear (LED_LED1);
delay_ms (5);
vLedSet (LED_LED1);
PWARNING ("Warning %d", test_count++);
vLedClear (LED_LED1);
delay_ms (5);
vLedSet (LED_LED1);
PNOTICE ("Notice %d", test_count++);
vLedClear (LED_LED1);
delay_ms (5);
vLedSet (LED_LED1);
PINFO ("Info %d", test_count++);
vLedClear (LED_LED1);
PDEBUG ("Debug %d", test_count++);
PERROR ("Error %d", test_count++);
PWARNING ("Warning %d", test_count++);
PNOTICE ("Notice %d", test_count++);
PINFO ("Info %d", test_count++);
PDEBUG ("Debug %d", test_count++);
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
uint16_t usAdc; // pour valeur ADC
double dValue; // pour la valeur de l'humidité
xAdcSensor xSensor;
/*
* Repère d'étalonnage utilisé pour le test
*
* Le capteur est un modèle HIH4030 de Honeywell. Il est connecté à la
* broche ADC0. C'est un capteur linéaire.
* Le datasheet nous donne les valeurs de tension en sortie:
* V1 = Vout(0%) = 958mV
* V2 = Vout(75.3%) = 3268mV
* comme Vref=5V, le quantum de l'ADC vaut LSB=5/1024=4.88mV donc :
* V1 = Vout(0%) = 958mV et ADC = 196 LSB
* V2 = Vout(75.3%) = 3268mV et ADC = 670 LSB
* Ce qui donne le repère xSetting = (0, 75.3, 196, 670)
*/
xAdcSensorSetting xSetting = ADC_SENSOR_SETTING_LINEAR(0, 75.3, 196, 670);
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
vLedInit(); // la LED1 est basculée à mesure
vAdcInit(); // Init de l'ADC
vAdcSetRef (eAdcVcc); // Tension de référence AVcc (5V pour Arduino UNO)
/*
* Le capteur est branché sur la voie 0 (ADC0)
* Moyennage sur 32 mesures
*/
vAdcSensorInit (&xSensor, &xSetting, ADC_SENSOR_LINEAR, 0, 32);
printf ("ADC0,Humidite\n");
for (;;) {
/*
* Lecture de la valeur brute en sortie de l'ADC :
* Si on n'a pas besoin de usAdc, on peut utiliser dAdcSensorGetValue()
* à la place de usAdcSensorGetRaw() et dAdcSensorRawToValue()
*/
usAdc = usAdcSensorGetRaw (&xSensor);
// Conversion de la valeur brute en grandeur mesurée.
dValue = dAdcSensorRawToValue (&xSensor, usAdc);
// Affichage des valeurs
printf ("%u,%.02f\n", usAdc, dValue);
vLedToggle (LED_LED1); // Bascule LED1 après chaque mesure
delay_ms (500);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
eTwiStatus eError;
uint8_t ucWaitTime = 10; // Temps d'attente en secondes
vLedInit ();
vSerialInit (TEST_BAUDRATE / 100, SERIAL_DEFAULT + SERIAL_RW);
stdout = &xSerialPort;
stdin = &xSerialPort;
printf_P (PSTR("\n\nTest unitaire RTC DS1339\n"));
vTwiInit ();
eError = eTwiSetSpeed (100);
vAssert (eError == TWI_SUCCESS);
vAssert (iRtcInit (TEST_DS1339) == 0);
printf_P(PSTR("Date courante: ")); prvvPrintRtc();
printf_P(PSTR("Modification Date ? (y/n) "));
while (ucWaitTime--) {
uint8_t ucCount = 10;
while ((ucCount--) && (usSerialHit() == 0)) {
// Boucle en attente appui d'une touche
delay_ms(100);
}
if (usSerialHit() != 0) {
char cKey;
cKey = getchar();
if ((cKey == 'y') || (cKey == 'Y')) {
prvvSetRtc();
}
break;
}
putchar('.');
}
putchar('\n');
for (;;) {
if (usSerialHit() != 0) {
(void) getchar(); // flush last char
prvvSetRtc();
}
prvvPrintRtc();
vLedToggle (LED_LED1);
delay_ms (1000);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
uint16_t usAdc; // pour valeur ADC
double dValue; // pour la valeur de la pression
xAdcSensor xSensor;
/*
* Repère d'étalonnage utilisé pour le test
*
* Le capteur est un modèle MPX4115AP de Freescale, sa tension de sortie est:
* Vout = Vcc*(.009*P-.095) avec P pression en kPa
* il s'agit bien d'un capteur linéaire.
* Le capteur mesure entre 150 hPa (15 kPa) et 1150 hPa (115 kPa).
* Pour Vcc=Vref=5V, le quantum de l'ADC vaut LSB=5/1024=4.88mV, ce qui donne:
* Vout(15) = 200mV = 41 LSB
* Vout(115) = 4700mV = 963 LSB
* Ce qui donne le repère xSetting = (150, 1150, 41, 963)
*/
xAdcSensorSetting xSetting = ADC_SENSOR_SETTING_LINEAR(150, 1150, 41, 963);
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
vLedInit(); // la LED1 est basculée à mesure
vAdcInit(); // Init de l'ADC
vAdcSetRef (eAdcVcc); // Tension de référence AVcc (5V pour Arduino UNO)
/*
* Capteur branché sur la voie 0 (ADC0)
* Moyennage sur 32 mesures
*/
vAdcSensorInit (&xSensor, &xSetting, ADC_SENSOR_LINEAR, 0, 32);
printf ("ADC0,Pression\n");
for (;;) {
/*
* Lecture de la valeur brute en sortie de l'ADC :
* Si on n'a pas besoin de usAdc, on peut utiliser dAdcSensorGetValue()
* à la place de usAdcSensorGetRaw() et dAdcSensorRawToValue()
*/
usAdc = usAdcSensorGetRaw (&xSensor);
// Conversion de la valeur brute en grandeur mesurée.
dValue = dAdcSensorRawToValue (&xSensor, usAdc);
// Affichage des valeurs
printf ("%u,%.02f\n", usAdc, dValue);
vLedToggle (LED_LED1); // Bascule LED1 après chaque mesure
delay_ms (500);
}
return 0;
}
/* internal public functions ================================================ */
int
main (void) {
xTaskHandle xTaskLed;
vLedInit ();
xTaskLed = xTaskCreate (xTaskConvertMs (50), vTaskLed);
vTaskStart (xTaskLed);
for (;;) {
/* Toggle the status of task every second */
delay_ms (1000);
bTaskEnabled = !bTaskEnabled;
}
return 0;
}
/* internal public functions ================================================ */
int
main (void) {
xTaskHandle xTaskLed;
vLedInit ();
xTaskLed = xTaskCreate (xTaskConvertMs (50), vTaskLed);
vTaskStart (xTaskLed);
for (;;) {
/* Bascule l'état de la LED chaque seconde */
delay_ms (1000);
xLedEnabled = !xLedEnabled;
}
return 0;
}
void __attribute__ ((noreturn)) mainloop (void)
{
prvSetupHardware ();
vLedInit ();
xTaskCreate (vUSBCDCTask, (signed portCHAR *) "USB", TASK_USB_STACK,
NULL, TASK_USB_PRIORITY, NULL);
vCmdInit ();
vInitProtocolLayer ();
vTaskStartScheduler ();
while (1);
}
/* main ===================================================================== */
int
main (void) {
uint16_t usAdc; // pour valeur ADC
char sep = ','; // caractère de séparation entre valeurs
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
vLedInit(); // la LED1 est basculée à série de mesures
vAdcInit(); // Init de l'ADC
vAdcSetRef (eAdcInternal); // Tension de référence interne (1.1V pour Arduino UNO)
// Affiche la ligne d'entête: ADC0,ADC1,...
for (int i = 0; i < ADC_CHAN_QUANTITY; i++) {
if (i == (ADC_CHAN_QUANTITY - 1)) {
// saut de ligne après dernière étiquette
sep = '\n';
}
printf ("ADC%u%c", i, sep);
}
for (;;) {
sep = ',';
// Affiche les valeurs ADC
for (int i = 0; i < ADC_CHAN_QUANTITY; i++) {
usAdc = usAdcReadAverage (i, 8); // lecture avec moyennage sur 8 valeurs
if (i == (ADC_CHAN_QUANTITY - 1)) {
// saut de ligne après dernière valeur
sep = '\n';
}
printf ("%u%c", usAdc, sep);
}
vLedToggle (LED_LED1); // Bascule LED1 après chaque série de mesure
delay_ms (1000);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
vLedInit ();
// Votre code d'initialisation devrait être ici
// Your initialization code should be here
for (;;) {
// Your main code should be here,
// you can delete the two lines below
// Votre code principal devrait être ici,
// Vous pouvrez supprimer les deux lignes ci-dessous
vLedToggle (LED_LED1);
delay_ms (1000);
}
return 0;
}
/* internal public functions ================================================ */
int
main (void) {
vLedInit();
for (;;) {
vWIfcInit ();
GetMid (ucMid);
GetPnCode (ucPnCode);
vAssert (memcmp_P (ucPnCode, ucPnCodeDef_P, sizeof(ucPnCodeDef_P)) == 0);
SetPnCode_P (ucPnCode_P);
GetPnCode (ucPnCode);
vAssert (memcmp_P (ucPnCode, ucPnCode_P, sizeof(ucPnCode_P)) == 0);
SetPnCode (ucPnCode);
vLedToggle (LED_LED1);
delay_ms (500);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
// Trame reçue et trame précédente
xBlyssFrame f, fprev;
vLedInit();
// Init. des trames
vBlyssFrameInit (&f, NULL);
vBlyssFrameInit (&fprev, NULL);
// Init. du module Blyss
vBlyssInit ();
sei(); // le module Blyss utilise les interruptions
for (;;) {
if (bBlyssReceive (&f)) {
// Une trame a été reçue
if (!bBlyssFrameMatch (&f, &fprev)) { // c'est une nouvelle trame...
uint8_t c = ucBlyssFrameChannel (&f);
if ( (c == MYCHAN) || (c == BLYSS_BROADCAST)) {
// la trame correspond à notre canal (ou à l'appel général)
if (bBlyssFrameState (&f)) {
vLedSet (LED_LED1);
}
else {
vLedClear (LED_LED1);
}
}
// On copie la trame dans la précédente
vBlyssFrameCopy (&fprev, &f);
}
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
int iError;
xHscSensor xSensor;
xHscRaw xRaw;
xHscValue xValue;
vLedInit();
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en sortie
FILE * serial_port = xFileOpen (PORT, O_WRONLY, &settings);
stdout = serial_port; // le port série est la sortie standard
stderr = serial_port;
sei();
printf ("\nTest unitaire HSC I2C\n");
vTwiInit ();
iError = eTwiSetSpeed (100);
assert (iError == 0);
iError = iHscInitTwiSensor (&xSensor, 0, 1600, HSC_DEFAULT_TWIADDR);
assert (iError == 0);
for (;;) {
iError = iHscGetRaw (&xSensor, &xRaw);
if (iError) {
printf ("Sensor Error: %d\n", iError);
}
else {
vHscRawToValue (&xSensor, &xRaw, &xValue);
printf ("Press %.02f Temp %.02f\n", xValue.dPress, xValue.dTemp);
}
vLedToggle (LED_LED1);
delay_ms (500);
}
return 0;
}
static inline void
prvSetupHardware (void)
{
/* When using the JTAG debugger the hardware is not always initialised to
the correct default state. This line just ensures that this does not
cause all interrupts to be masked at the start. */
AT91C_BASE_AIC->AIC_EOICR = 0;
/* Enable the peripheral clock. */
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_PIOA) | (1 << AT91C_ID_PIOB);
/* Init LEDs */
vLedInit ();
/* If no previous environment exists - create a new, but don't store it */
env_init ();
if (!env_load ()) {
vResetEnv();
}
}
void __attribute__ ((noreturn)) mainloop (void)
{
prvSetupHardware ();
vLedInit ();
PtCmdInit ();
vNetworkInit ();
PtInitProtocol ();
xLogfile = xQueueCreate (SECTOR_BUFFER_SIZE * 2, sizeof (char));
xTaskCreate (vUSBCDCTask, (signed portCHAR *) "USB", TASK_USB_STACK,
NULL, TASK_USB_PRIORITY, NULL);
xTaskCreate (vFileTask, (signed portCHAR *) "FILE", TASK_FILE_STACK,
NULL, TASK_FILE_PRIORITY, NULL);
vTaskStartScheduler ();
while (1);
}
/* internal public functions ================================================ */
int
main(void) {
vLedInit();
vSerialInit (SER_BAUDRATE/100, SERIAL_DEFAULT + SERIAL_WR);
vAfskInit (AFSK_MODE_NOBLOCK);
vAx25Init (&ax25, &xAfskPort, &xAfskPort, NULL);
sei();
for (;;) {
static uint16_t usCount;
char msg[80];
// Numérotation de la trame afin de suivre la perte éventuelle à la
// réception
snprintf (msg, sizeof(msg), APRS_MSG, usCount++);
vAx25SendVia (&ax25, path, countof(path), msg, strlen(msg));
delay_ms (TX_PERIOD_MS);
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
vLedInit();
vSerialSwInit ();
stdout = &xSerialSwPort;
stdin = &xSerialSwPort;
sei();
for (;;) {
vTestDebug ();
vTestAlphabet ();
vTestPong();
vTestPongStdIo();
vTestStdio ();
#if TEST_DELAY != 0
delay_ms (TEST_DELAY);
#endif
}
return 0;
}
/* internal public functions ================================================ */
int
main(void) {
int i;
vLedInit ();
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en entrée et en sortie
FILE * serial_port = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
vTncInit (&tnc, serial_port, serial_port);
sei();
for (i = 0; i < TNC_RXBUFSIZE; i++)
msg[i] = i;
xScheduler = xTaskCreate (xTaskConvertMs (TRANSMIT_PERIOD), vScheduler);
vTaskStart (xScheduler);
for (;;) {
i = iTncPoll (&tnc);
vAssert (i >= 0);
if (i == TNC_EOT) {
for (i = 0; i < tnc.len; i++)
vAssert (tnc.rxbuf[i] == i);
vLedToggle (LED_LED1);
}
if (xMutexTryLock(&xMutexTx) == 0) {
i = iTncWrite (&tnc, msg, sizeof(msg));
vAssert (i == sizeof(msg));
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
uint16_t usPulse = DEFAULT_PULSE;
vLedInit ();
vButInit ();
vServoInit (); // Toutes les voies sont validées
// Règlage des largeurs d'impulsion par défaut
vLedSet (LED_LED1);
for (uint8_t ucServo = 0; ucServo < ucServoChannels(); ucServo++) {
vServoSetPulse (ucServo, DEFAULT_PULSE);
}
for (;;) {
if (xButGet (BUTTON_BUTTON1)) {
// BP1 appuyé
while (xButGet (BUTTON_BUTTON1))
; // Attente relâchement BP1
usPulse += STEP_PULSE; // Augmente la largeur d'un pas
// Si la largeur est trop grande, on revient au min
if (usPulse > MAX_PULSE) {
usPulse = MIN_PULSE;
}
// On envoie le nouveau réglage aux servos
for (uint8_t ucServo = 0; ucServo < ucServoChannels(); ucServo++) {
vServoSetPulse (ucServo, usPulse);
}
// On bascule l'état de la LED1
vLedToggle (LED_LED1);
}
}
return 0;
}
/* internal public functions ================================================ */
int
main (void) {
uint8_t ucBit;
vLedInit ();
vButInit ();
for (;;) {
for (ucBit = 0; ucBit < BUTTON_QUANTITY; ucBit++) {
if (xButGet (xButGetMask (ucBit))) {
uint8_t ucCount = (ucBit + 1) * 2;
while (ucCount--) {
// La LED clignote une fois pour le bouton 1, 2 fois pour le 2 ....
vLedToggle (LED_LED1);
delay_ms (200);
}
}
}
}
return 0;
}
/* internal public functions ================================================ */
int
main(void) {
vLedInit ();
// Configuration du port série par défaut (8N1, sans RTS/CTS)
xSerialIos settings = SERIAL_SETTINGS (BAUDRATE);
// Ouverture du port série en entrée et en sortie
FILE * serial_port = xFileOpen (PORT, O_RDWR | O_NONBLOCK, &settings);
sei();
vTncInit (&tnc, serial_port, serial_port);
sei();
for (;;) {
i = iTncPoll (&tnc);
vAssert (i >= 0);
if (i == TNC_EOT) {
uint16_t usLen = tnc.len;
i = iTncWrite (&tnc, &usLen, sizeof(usLen));
}
}
return 0;
}
// -----------------------------------------------------------------------------
// Le programme principal
int
main (void) {
vLedInit();
vSerialInit (DEBUG_BAUDRATE / 100, SERIAL_DEFAULT + SERIAL_RW);
stdout = &xSerialPort;
printf_P (PSTR("\r\riDwaRF - Firmware v" __IDWARF_VERSION_STRING__ " Hub version\n\n"));
// initialise le firmware iDwaRF
printf_P(PSTR("Init... "));
rfInit(); // les interruptions sont validées...
vPrintOk();
// Enregistre les fonctions de traitement de l'utilisateur
printf_P(PSTR("Register Call Back functions... "));
rfRegisterCBSensorDataReceived (vSensorPacketReceived);
vPrintOk();
vPrintStatus();
vPrintBeaconTime();
vPrintHelp();
puts_P(PSTR("\nProcess All ..."));
for (;;) {
// la boucle principale gère les événements du réseau...
rfProcessAll();
// if the serial callback has set this flag, there is new data to be processed.
// done here to prevent overload in the callback function
if (usSerialHit()) {
vProcessRxData();
}
// show the saved data received with the last sensor packet
// OutStr takes some time - that's the reason why it is done here!
// ucData holds the data and ucDataLen is the amount of data stored in ucData.
if (ucDataLen > 0) {
uint8_t * pucData = ucData;
if ((ucFlags & HEX_FLAG) == 0) { // show data user friendly
if (ucDataLen >= 1) {
// Push Button state - 1 byte
printf_P (PSTR("Button %s"), (*pucData++ != 0 ? "ON " : "off"));
}
if (ucDataLen >= 2) {
uint8_t ucBatt;
// Battery voltage - 1 byte
ucBatt = *pucData++;
printf_P (PSTR(" Batt <0x%02X> %.2fV"), ucBatt, ADC_SCALE * (float) ucBatt / 256.0);
}
if (ucDataLen >= 4) {
int16_t iTemp;
// Temperature value - 2 bytes
iTemp = (*pucData++) << 8;
iTemp += *pucData++;
printf_P (PSTR(" Temp (0x%02X) %.1foC"), iTemp, (float)iTemp / 10.0);
}
if (ucDataLen >= 5) {
// Light Dependent Resistor value - 1 byte
printf_P (PSTR(" Ldr %d"), *pucData++);
}
}
while (pucData < (ucData + ucDataLen)) {
printf_P (PSTR("%02X "), *pucData++);
}
// show the payload size
printf_P (PSTR("> len=%d\n"), ucDataLen);
ucDataLen = 0; // reset. Otherwise this data is displayed non stop.
}
}
}
/* main ===================================================================== */
int
main (void) {
eGifamMode eNewMode = ModeConfort; // Mode de départ
eGifamMode eCurrentMode = ModeUnknown;
int iTimeOut = 16;
// Initialisation des fonctions
vLedInit();
vButInit();
vTwiInit ();
eTwiSetSpeed (400);
// Attente de réponse du tiny45, nécessaire lors d'un démarrage de l'alim.
while (iGifamInit () != 0) {
if (iTimeOut-- <= 0) {
vAssert (0); // bloque et fait clignoter la led 7
}
delay_ms (100);
}
for (;;) {
if (eNewMode != eCurrentMode) {
while (eNewMode != eCurrentMode) {
// Le nouveau mode est différent du courant
vGifamSet (eNewMode); // modification du mode
eCurrentMode = eGifamGet(); // lecture du mode
if (eNewMode != eCurrentMode) {
delay_ms (500);
vLedToggle (LED_LED1);
}
}
vLedClear (LED_LED1);
}
// Attente appui BP
while (xButGet (BUTTON_BUTTON1) == 0)
;
if ( (eNewMode == ModeEco) || (eNewMode == ModeConfortM1)) {
// Remets le fil au repos afin de pouvoir mesurer la durée d'activation
// des modes étendus
vGifamSet (ModeConfort);
// Attente appui BP
delay_ms (250);
while (xButGet (BUTTON_BUTTON1) == 0) {
vLedToggle (LED_LED1);
delay_ms (50);
}
}
vLedClear (LED_LED1);
delay_ms (250);
// Passe au mode suivant
if (eNewMode < ModeConfortM2) {
eNewMode++;
}
else {
eNewMode = ModeConfort;
}
}
return 0;
}
/* main ===================================================================== */
int
main (void) {
int c, count;
uint8_t channel = DEFAULT_CHANNEL;
bool state = false;
bool loop = false;
bool txreq = false;
xBlyssFrame f;
xSerialIos xTermIos = SERIAL_SETTINGS (TERMINAL_BAUDRATE);
vLedInit();
FILE * tc = xFileOpen (TERMINAL_PORT, O_RDWR | O_NONBLOCK, &xTermIos);
stdout = tc;
stderr = tc;
stdin = tc;
sei();
printf_P (PSTR ("** Blyss Transmitter Test **\n"
"Channel: %u\n"
"Press 0 for OFF, 1 for ON, 2 for Loop...\n"), channel);
vBlyssInit ();
vBlyssFrameInit (&f, my_id);
vBlyssFrameSetChannel (&f, channel);
for (;;) {
if ( (c = getchar()) != EOF) {
switch (c) {
case '0':
state = false;
loop = false;
txreq = true;
printf_P (PSTR("\nLight OFF\n"));
break;
case '1':
state = true;
txreq = true;
loop = false;
printf_P (PSTR("\nLight ON\n"));
break;
case '2':
loop = true;
count = 0;
printf_P (PSTR("\nLoop ON/OFF\n"));
break;
default:
break;
}
}
if (txreq) {
vBlyssFrameSetState (&f, state);
vBlyssSend (&f, 4);
vBlyssPrintFrame (&f);
txreq = false;
}
if (loop) {
if (count-- == 0) {
state = !state;
txreq = true;
count = LOOP_TIME / 100;
}
delay_ms (100);
}
}
return 0;
}
// -----------------------------------------------------------------------------
INLINE void
vMBLedInit (void) {
#if defined(MB_SERIAL_LEDERR) || (defined(MB_SERIAL_LEDCOM) && defined(MB_SERIAL_LEDCOM_DELAY))
vLedInit();
#endif
}
// -----------------------------------------------------------------------------
// the main entry for the user Software
int
main (void) {
bool xOldButton = false;
vLedInit();
vButInit();
prvvDebugInit();
vDbgPuts_P (PSTR("Testcode for the tutorial - hub style\r"));
// initialize the RF - Firmware
rfInit();
// register callback: function called, each time a sensor data packet is received
rfRegisterCBSensorDataReceived (cbSensorPacketReceived);
// the main loop
for (;;) {
if (xButGet(BUTTON) == BUTTON) {
if (xOldButton == false) {
// debug output
for (uint8_t n = 0; n < 10; n ++) {
vDbgPutDec (ucValid[n]);
vDbgPutc ('.');
}
vDbgPutc (' ');
// search for the next value sensor id
for (ucValue++; ucValue < 10; ucValue++) {
if (ucValid[ucValue])
break;
}
if (ucValue == 10) { // if overflow | no sensor ucValid, search again
for (ucValue = 0; ucValue < 10; ucValue++) {
if (ucValid[ucValue])
break;
}
}
if (ucValue == 10)
ucValue = 0; // no sensor ucValid - fallback to id 0
// debug output
vDbgPutDec (ucValue);
vDbgPutc (' ');
// mark all sensors as not ucValid for the next iteration
for (uint8_t n = 0; n < 10; n++) {
ucValid[n] = 0;
}
xOldButton = true;
}
}
else {
if (xOldButton == true)
xOldButton = false;
}
rfProcessAll();
}
}
