int main(void){
mPORTASetPinsDigitalIn(0xFFFF);
mPORTBSetPinsAnalogIn(0xFFFF); //Enable all analog
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
CloseADC10();
SetChanADC10(INITCH);
OpenADC10(CONFIG1, CONFIG2, CONFIG3, CFGPORT, CFGSCAN);
ConfigIntADC10(CFGINT);
EnableADC10();
//Initialize the DB_UTILS IO channel
DBINIT();
// Display the introduction
DBPRINTF("Welcome to the Analog Input Test.\n");
DBPRINTF("The build date and time is (" __DATE__ "," __TIME__ ")\n");
while (1){
//Get damper value from PIC analog input
int i = 0;
for(i;i<16;i++){
int damper = ReadADC10(i);
DBPRINTF("Damper %d = %d", i, damper);
DBPRINTF("\n");
}
//DBPRINTF("%d \n", LATA );
}
return 0;
}
int main(int argc, char** argv) {
//DDPCONbits.JTAGEN = 0; // Disable JTAG
mPORTGSetPinsDigitalIn(0x00FF);
mPORTBSetPinsAnalogIn(0x00FF); //Enable all analog
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
CloseADC10();
SetChanADC10(INITCH);
OpenADC10(CONFIG1, CONFIG2, CONFIG3, CFGPORT, CFGSCAN);
ConfigIntADC10(CFGINT);
EnableADC10();
//Initialize the DB_UTILS IO channel
DBINIT();
// Display the introduction
DBPRINTF("Welcome to the Analog Input Test.\n");
DBPRINTF("The build date and time is (" __DATE__ "," __TIME__ ")\n");
while (1){
//Get damper value from PIC analog input
int i = 0;
for(i;i<1;i++){
int analog = ReadADC10(i);
DBPRINTF("Hammer %d = %d", i, analog);
DBPRINTF("\n");
}
int digital = mPORTGReadBits(BIT_0);
DBPRINTF("digital: %X \n \n", digital );
}
return 0;
}
void APP_Initialize(void)
{
/* Place the App state machine in its initial state. */
appData.state = APP_STATE_INIT;
DBINIT();
SYS_PRINT("=== Initializing wolfMQTT ===\n");
mqtt_init_ctx(&mqttCtx);
mqttCtx.app_name = "mqttclient";
mqttCtx.qos = MQTT_QOS_2;
mqttCtx.use_tls = 1;
/* TODO: Add any additional custom args here.
See MQTTCtx struct in mqttexample.h */
}
/*
* Main driver for CTaoCrypt tests.
*/
int main(int argc, char** argv) {
int i ;
init_serial() ; /* initialize PIC32MZ serial I/O */
SYSTEMConfigPerformance(80000000);
DBINIT();
printf("CTaoCrypt Test:\n");
func_args args;
args.argc = argc;
args.argv = argv;
ctaocrypt_test(&args);
if (args.return_code == 0) {
printf("All tests passed!\n");
}
return 0;
}
/*
* Main driver for WolfCrypt tests.
*/
int main(int argc, char** argv)
{
func_args args;
SYSTEMConfigPerformance(SYS_CLK);
DBINIT();
init_serial(SYS_CLK) ; /* initialize PIC32MZ serial I/O */
printf("WolfCrypt Test:\n");
args.argc = argc;
args.argv = argv;
wolfcrypt_test(&args);
if (args.return_code == 0) {
printf("All tests passed!\n");
}
return 0;
}
int main(int argc, char** argv)
{
int ret;
int i;
(void)argc;
(void)argv;
#if defined(MICROCHIP_PIC32)
init_serial() ; /* initialize PIC32MZ serial I/O */
SYSTEMConfigPerformance(80000000);
DBINIT();
#endif
/* align key, iv pointers */
key = (byte*)XMALLOC(32, NULL, DYNAMIC_TYPE_KEY);
if (key == NULL) {
printf("mcapi key alloc failed\n");
return -1;
}
iv = (byte*)XMALLOC(16, NULL, DYNAMIC_TYPE_KEY);
if (iv == NULL) {
printf("mcapi iv alloc failed\n");
return -1;
}
for (i = 0; i < OUR_DATA_SIZE; i++)
ourData[i] = (byte)i;
ret = check_md5();
if (ret != 0) {
printf("mcapi check_md5 failed\n");
return -1;
}
ret = check_sha();
if (ret != 0) {
printf("mcapi check_sha failed\n");
return -1;
}
ret = check_sha256();
if (ret != 0) {
printf("mcapi check_sha256 failed\n");
return -1;
}
ret = check_sha384();
if (ret != 0) {
printf("mcapi check_sha384 failed\n");
return -1;
}
ret = check_sha512();
if (ret != 0) {
printf("mcapi check_sha512 failed\n");
return -1;
}
ret = check_hmac();
if (ret != 0) {
printf("mcapi check_hmac failed\n");
return -1;
}
ret = check_compress();
if (ret != 0) {
printf("mcapi check_compress failed\n");
return -1;
}
ret = check_rng();
if (ret != 0) {
printf("mcapi check_rng failed\n");
return -1;
}
ret = check_des3();
if (ret != 0) {
printf("mcapi check_des3 failed\n");
return -1;
}
ret = check_aescbc();
if (ret != 0) {
printf("mcapi check_aes cbc failed\n");
return -1;
}
ret = check_aesctr();
if (ret != 0) {
printf("mcapi check_aes ctr failed\n");
return -1;
}
ret = check_aesdirect();
if (ret != 0) {
printf("mcapi check_aes direct failed\n");
return -1;
}
ret = check_rsa();
if (ret != 0) {
printf("mcapi check_rsa failed\n");
return -1;
}
ret = check_ecc();
if (ret != 0) {
printf("mcapi check_ecc failed\n");
return -1;
}
XFREE(iv, NULL, DYNAMIC_TYPE_KEY);
XFREE(key, NULL, DYNAMIC_TYPE_KEY);
return 0;
}
void board_init(){
DDPCONbits.JTAGEN = 0; //disable JTAG
DBINIT(); // Initialize the IO channel
hal_allUARTInit(); //Initialize all UARTs
keypad_init(); //Initialize keypad
}
/*
* Main driver for CTaoCrypt benchmarks.
*/
int main(int argc, char** argv) {
volatile int i ;
int j ;
init_serial() ; /* initialize PIC32MZ serial I/O */
SYSTEMConfigPerformance(80000000);
DBINIT();
current_time(1) ;
for(j=0; j<100; j++) {
for(i=0; i<100000; i++) ;
printf("%f\n", current_time(0)) ;
}
printf("wolfCrypt Benchmark:\n");
#ifndef NO_AES
bench_aes(0);
bench_aes(1);
#endif
#ifdef HAVE_AESGCM
bench_aesgcm();
#endif
#ifndef NO_RC4
bench_arc4();
#endif
#ifdef HAVE_HC128
bench_hc128();
#endif
#ifndef NO_RABBIT
bench_rabbit();
#endif
#ifndef NO_DES3
bench_des();
#endif
printf("\n");
#ifndef NO_MD5
bench_md5();
#endif
bench_sha();
#ifndef NO_SHA256
bench_sha256();
#endif
#ifdef CYASSL_SHA512
bench_sha512();
#endif
#ifdef CYASSL_RIPEMD
bench_ripemd();
#endif
printf("\n");
#ifndef NO_RSA
bench_rsa();
#endif
#ifndef NO_DH
bench_dh();
#endif
#if defined(CYASSL_KEY_GEN) && !defined(NO_RSA)
bench_rsaKeyGen();
#endif
#ifdef HAVE_ECC
bench_eccKeyGen();
bench_eccKeyAgree();
#endif
printf("End of wolfCrypt Benchmark:\n");
return 0;
}
// main() ---------------------------------------------------------------------
//
int main(void)
{
int pbClk; // Peripheral bus clock
// Configure the device for maximum performance, but do not change
// the PBDIV clock divisor. Given the options, this function will
// change the program Flash wait states, RAM wait state and enable
// prefetch cache, but will not change the PBDIV. The PBDIV value
// is already set via the pragma FPBDIV option above.
pbClk = SYSTEMConfig(CPU_HZ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
// The pic32 has 2 programming i/f's: ICD/ICSP and JTAG. The
// starter kit uses JTAG, whose pins are muxed w/ RA0,1,4 & 5.
// If we wanted to disable JTAG to use those pins, we'd need:
#if defined M4557_DUINOMITE
DDPCONbits.JTAGEN = 0; // Disable the JTAG port.
#endif
// Pins that share ANx functions (analog inputs) will default to
// analog mode (AD1PCFG = 0x0000) on reset. To enable digital I/O
// Set all ones in the ADC Port Config register. (I think it's always
// PORTB that is shared with the ADC inputs). PORT B is NOT 5v tolerant!
// Also, RB6 & 7 are the ICD/ICSP lines.
AD1PCFG = 0xffff; // Port B as digital i/o.
//Initialize the DB_UTILS IO channel
DBINIT();
#if defined ST7565_M4557_PROTOTYPE_STARTERKIT
// Enable pullup resistors for Starter Kit's 3 switches.
//CNPUE = (CN15_PULLUP_ENABLE | CN16_PULLUP_ENABLE | CN19_PULLUP_ENABLE);
mCNOpen(CN_ON, CN15_ENABLE | CN16_ENABLE,
CN15_PULLUP_ENABLE | CN16_PULLUP_ENABLE | CN19_PULLUP_ENABLE);
// Read the port to clear any mismatch on change notice pins
dummy = mPORTDRead();
// Clear change notice interrupt flag
ConfigIntCN(CHANGE_INT_ON | CHANGE_INT_PRI_2);
// Ok now to enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
// Display the introduction
DBPUTS("SW1:Set contrast; SW2:Halt display\n");
//DBPRINTF("DBPRINTF: The build date and time is (" __DATE__ "," __TIME__ ")\n");
// Init ports for ST7565 parallel prototype setup (using pic32 starter kit
// and i/o expansion board): TODO: This belongs somewhere else!!
//
// PIC32 NHD Display
// RB10 /CS1, /RES, A0, /WR, /RD
// RE0..7 D0..7
LATBSET = 0x7C00; // Set the control bits high (inactive)
TRISBCLR = 0x7C00; // Set the control bits as outputs.
// Init ESI touch-screen controller's (TSC2046) CS line as output
LATFSET = BIT_5; // Set CSn inactive...
TRISFCLR = BIT_5; // and set as output
// Data is on port E. The LCD controller (ST7565) uses its parallel
// mode on port E, RE0..7. The touch screen controller shares port
// shares a serial interface on some of these bits.
TRISECLR = 0x00ff; // Set the cmd/data bits as outputs.
#elif defined M4557_DUINOMITE
// Init ports for the M4557.
//
// Control bits are on port B:
//
// bit M4557 function
// ---- --------------
// 3 /CS1 - LCD Chip sel (ST7565 controller)
// 4 /RES - Reset
// 6 A0 -
// 7 /WR - Write
// 9 /RD - Read
// 10 /TPCS - Touch panel Chip Sel (TSC2046)
//
// Set the control bits low, and enable as outputs.
LATBSET = (BIT_3|BIT_4|BIT_6|BIT_7|BIT_9|BIT_10);
TRISBCLR = (BIT_3|BIT_4|BIT_6|BIT_7|BIT_9|BIT_10);
// Data is on port E. The LCD controller (ST7565) uses its parallel
// mode on port E, RE0..7. The touch screen controller shares port
// shares a serial interface on some of these bits.
TRISECLR = 0x00ff; // Set the cmd/data bits as outputs.
#else
#error Need product defined
#endif
Nop();
lcdInit(5,35); // Init lcd controller
Nop();
// Output Compare (PWM) pins
//
// OCn 64pin 100pin/port SKII-J11- Duinomite
// --- ----- ----------- -------------- ----------
// OC1 46 72/RD0 19 (LED1,Red) SOUND
// OC2 49 76/RD1 20 (LED2,Yel) D13,SD_CLK
// OC3 50 77/RD2 17 (LED3,Grn) D12,SD_MISO
// OC4 51 78/RD3 18 D11,SD_MOSI
// OC5 52 81 15 vga_hsync
//
// Init Timer 2 for use by the OC (PWM) module(s).
// This will set the PWM frequency, f = pbClk/reloadValue.
// Examples (pcClk = 40MHz):
// f = pbClk/100000 = 400Hz
// f = pbClk/10000 = 4kHz
// f = pbClk/2500 = 20kHz
//
//OpenTimer2(T2_ON | T2_32BIT_MODE_ON, 100000); // f = pbClk/100000 = 400Hz
//OpenTimer2(T2_ON | T2_32BIT_MODE_ON, 10000); // f = pbClk/10000 = 4kHz
OpenTimer2(T2_ON | T2_32BIT_MODE_ON, 2500); // f = pbClk/2500 = 16kHz
// I tried the uChip example using "OpenOC2", and as is ofter the
// case, I can't get it to work, the documentation is lacking, and
// it's easier to just read the datasheet and program the bloody
// OCxCON register directly.
//OpenOC2( OC_ON | OC_TIMER_MODE32 | OC_TIMER2_SRC | OC_CONTINUE_PULSE | OC_LOW_HIGH , 40000, 30000 );
SetDCOC2PWM(0);
OC2CON = 0x8026; // OC on; 32bit-mode; PWM mode.
SetDCOC3PWM(0);
OC3CON = 0x8026; // OC on; 32bit-mode; PWM mode.
/*
int testOnly = 1;
uint32_t loadVal = 0;
int i;
while(testOnly)
{
// Try the dimmer's 16 levels (0..15)
for(i=0; i<16; i++)
{
loadVal = pwmTable1[i];
SetDCOC2PWM(loadVal);
delay_ms(300);
}
}
CloseOC2();
*/
// Do ESI M4557 demo application (dimmer-control type demo w/ touchscreen)
esi_M4557();
return 0;
}
int main(void)
{
DBINIT();
DBPRINTF("MAIN.... \n");
unsigned int temp;
int POWER;
//bool RELAY;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//STEP 1. Configure cache, wait states and peripheral bus clock
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 2. configure the port registers
mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2 | BIT_9);
mPORTESetPinsDigitalOut(BIT_0 | BIT_1 | BIT_2);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 3. initialize the port pin states = outputs low
mPORTDClearBits(BIT_0 | BIT_1 | BIT_2);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 4. enable change notice, enable discrete pins and weak pullups
mCNOpen(CONFIG, PINS, PULLUPS);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 5. read port(s) to clear mismatch on change notice pins
temp = mPORTDRead();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 6. clear change notice interrupt flag
ConfigIntCN(INTERRUPT);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 7. enable multi-vector interrupts
INTEnableSystemMultiVectoredInt();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// STEP 8. configure SPI port and MCP3909
OpenSPI1(FRAME_ENABLE_ON | ENABLE_SDO_PIN | SPI_MODE32_ON | SPI_CKE_ON | SLAVE_ENABLE_OFF | CLK_POL_ACTIVE_LOW | MASTER_ENABLE_ON , SPI_ENABLE | SPI_FRZ_CONTINUE | SPI_IDLE_STOP | SPI_RX_OVFLOW_CLR);
CONFIG_3909();
DBPRINTF("CONFIGURED.... \n");
while(1)
{
// Toggle LED's to signify code is looping
mPORTDToggleBits(BIT_0); // toggle LED1 (same as LATDINV = 0x0002)
SAMPLE();
POWER = MEASURE_POWER();
DBPRINTF("power measured! \n");
DelayMs(1000);
/************************
*ETHERNET COMMUNICATIONS*
************************/
};
}
void Console_APPIO_Tasks (SYS_MODULE_OBJ object)
{
/* Update the application state machine based
* on the current state */
struct QPacket pkt;
size_t *sizeRead;
switch(consAppIOData.state)
{
case CONSOLE_APPIO_STATE_INIT:
/* Initialize APPIO */
DBINIT();
consAppIOData.state = CONSOLE_APPIO_STATE_READY;
break;
case CONSOLE_APPIO_STATE_START_READ:
if (readQueue.numElem)
{
pkt = rdQueueElements[readQueue.tailPos];
DBGETS (pkt.data.buf, 128);
if (*(char*)pkt.data.buf != '\0')
{
rdQueueElements[readQueue.tailPos].sz = strlen((char*)pkt.data.buf);
consAppIOData.state = CONSOLE_APPIO_STATE_READ_COMPLETE;
}
}
break;
case CONSOLE_APPIO_STATE_READ_COMPLETE:
sizeRead = &rdQueueElements[readQueue.tailPos].sz;
popQueue(&readQueue);
if (readQueue.numElem == 0)
{
if (consAppIOData.rdCallback != NULL)
{
consAppIOData.rdCallback(sizeRead);
}
consAppIOData.state = CONSOLE_APPIO_STATE_READY;
}
else
{
consAppIOData.state = CONSOLE_APPIO_STATE_START_READ;
}
break;
case CONSOLE_APPIO_STATE_READY:
if (writeQueue.numElem)
{
consAppIOData.state = CONSOLE_APPIO_STATE_START_WRITE;
}
else if (readQueue.numElem)
{
consAppIOData.state = CONSOLE_APPIO_STATE_START_READ;
}
break;
case CONSOLE_APPIO_STATE_START_WRITE:
if (writeQueue.numElem)
{
pkt = wrQueueElements[writeQueue.tailPos];
DBPRINTF("%s",(char*)pkt.data.buf);
consAppIOData.writeCycleCount = 0;
consAppIOData.state = CONSOLE_APPIO_STATE_WAIT_FOR_WRITE_COMPLETE;
}
break;
case CONSOLE_APPIO_STATE_WAIT_FOR_WRITE_COMPLETE:
pkt = wrQueueElements[writeQueue.tailPos];
/* Burn cycles to allow to printf to complete */
if(consAppIOData.writeCycleCount++ > pkt.sz * 400)
{
if (consAppIOData.wrCallback != NULL)
{
consAppIOData.wrCallback((void *)pkt.data.cbuf);
}
popQueue(&writeQueue);
if (writeQueue.numElem == 0)
{
consAppIOData.state = CONSOLE_APPIO_STATE_READY;
}
else
{
consAppIOData.state = CONSOLE_APPIO_STATE_START_WRITE;
}
}
break;
case CONSOLE_APPIO_STATE_OPERATIONAL_ERROR:
/* We arrive at this state if the APPIO driver reports an error on a read or write operation
We will attempt to recover by flushing the local buffers */
Console_APPIO_Flush();
break;
case CONSOLE_APPIO_STATE_CRITICAL_ERROR:
break;
default:
break;
}
}
int main(void)
{
UINT8 i2cData[10];
I2C_7_BIT_ADDRESS SlaveAddress;
int Index;
int DataSz;
UINT32 actualClock;
BOOL Acknowledged;
BOOL Success = TRUE;
UINT8 i2cbyte;
// Initialize debug messages (when supported)
DBINIT();
// Set the I2C baudrate
actualClock = I2CSetFrequency(EEPROM_I2C_BUS, GetPeripheralClock(), I2C_CLOCK_FREQ);
if ( abs(actualClock-I2C_CLOCK_FREQ) > I2C_CLOCK_FREQ/10 )
{
DBPRINTF("Error: I2C1 clock frequency (%u) error exceeds 10%%.\n", (unsigned)actualClock);
}
// Enable the I2C bus
I2CEnable(EEPROM_I2C_BUS, TRUE);
//
// Send the data to EEPROM to program one location
//
// Initialize the data buffer
I2C_FORMAT_7_BIT_ADDRESS(SlaveAddress, EEPROM_ADDRESS, I2C_WRITE);
i2cData[0] = SlaveAddress.byte;
i2cData[1] = 0x05; // EEPROM location to program (high address byte)
i2cData[2] = 0x40; // EEPROM location to program (low address byte)
i2cData[3] = 0xAA; // Data to write
DataSz = 4;
// Start the transfer to write data to the EEPROM
if( !StartTransfer(FALSE) )
{
while(1);
}
// Transmit all data
Index = 0;
while( Success && (Index < DataSz) )
{
// Transmit a byte
if (TransmitOneByte(i2cData[Index]))
{
// Advance to the next byte
Index++;
// Verify that the byte was acknowledged
if(!I2CByteWasAcknowledged(EEPROM_I2C_BUS))
{
DBPRINTF("Error: Sent byte was not acknowledged\n");
Success = FALSE;
}
}
else
{
Success = FALSE;
}
}
// End the transfer (hang here if an error occured)
StopTransfer();
if(!Success)
{
while(1);
}
// Wait for EEPROM to complete write process, by polling the ack status.
Acknowledged = FALSE;
do
{
// Start the transfer to address the EEPROM
if( !StartTransfer(FALSE) )
{
while(1);
}
// Transmit just the EEPROM's address
if (TransmitOneByte(SlaveAddress.byte))
{
// Check to see if the byte was acknowledged
Acknowledged = I2CByteWasAcknowledged(EEPROM_I2C_BUS);
}
else
{
Success = FALSE;
}
// End the transfer (stop here if an error occured)
StopTransfer();
if(!Success)
{
while(1);
}
} while (Acknowledged != TRUE);
//
// Read the data back from the EEPROM.
//
// Initialize the data buffer
I2C_FORMAT_7_BIT_ADDRESS(SlaveAddress, EEPROM_ADDRESS, I2C_WRITE);
i2cData[0] = SlaveAddress.byte;
i2cData[1] = 0x05; // EEPROM location to read (high address byte)
i2cData[2] = 0x40; // EEPROM location to read (low address byte)
DataSz = 3;
// Start the transfer to read the EEPROM.
if( !StartTransfer(FALSE) )
{
while(1);
}
// Address the EEPROM.
Index = 0;
while( Success & (Index < DataSz) )
{
// Transmit a byte
if (TransmitOneByte(i2cData[Index]))
{
// Advance to the next byte
Index++;
}
else
{
Success = FALSE;
}
// Verify that the byte was acknowledged
if(!I2CByteWasAcknowledged(EEPROM_I2C_BUS))
{
DBPRINTF("Error: Sent byte was not acknowledged\n");
Success = FALSE;
}
}
// Restart and send the EEPROM's internal address to switch to a read transfer
if(Success)
{
// Send a Repeated Started condition
if( !StartTransfer(TRUE) )
{
while(1);
}
// Transmit the address with the READ bit set
I2C_FORMAT_7_BIT_ADDRESS(SlaveAddress, EEPROM_ADDRESS, I2C_READ);
if (TransmitOneByte(SlaveAddress.byte))
{
// Verify that the byte was acknowledged
if(!I2CByteWasAcknowledged(EEPROM_I2C_BUS))
{
DBPRINTF("Error: Sent byte was not acknowledged\n");
Success = FALSE;
}
}
else
{
Success = FALSE;
}
}
// Read the data from the desired address
if(Success)
{
if(I2CReceiverEnable(EEPROM_I2C_BUS, TRUE) == I2C_RECEIVE_OVERFLOW)
{
DBPRINTF("Error: I2C Receive Overflow\n");
Success = FALSE;
}
else
{
while(!I2CReceivedDataIsAvailable(EEPROM_I2C_BUS));
i2cbyte = I2CGetByte(EEPROM_I2C_BUS);
}
}
// End the transfer (stop here if an error occured)
StopTransfer();
if(!Success)
{
while(1);
}
// Validate the data read
if( i2cbyte != 0xAA )
{
DBPRINTF("Error: Verify failed\n");
}
else
{
DBPRINTF("Success\n");
}
// Example complete
while(1);
}
/*
* Main driver for CTaoCrypt benchmarks.
*/
int main(int argc, char** argv) {
SYSTEMConfigPerformance(80000000);
DBINIT();
printf("CTaoCrypt Benchmark:\n");
#ifndef NO_AES
bench_aes(0);
bench_aes(1);
#endif
#ifdef HAVE_AESGCM
bench_aesgcm();
#endif
#ifndef NO_RC4
bench_arc4();
#endif
#ifdef HAVE_HC128
bench_hc128();
#endif
#ifndef NO_RABBIT
bench_rabbit();
#endif
#ifndef NO_DES3
bench_des();
#endif
printf("\n");
#ifndef NO_MD5
bench_md5();
#endif
bench_sha();
#ifndef NO_SHA256
bench_sha256();
#endif
#ifdef CYASSL_SHA512
bench_sha512();
#endif
#ifdef CYASSL_RIPEMD
bench_ripemd();
#endif
printf("\n");
#ifndef NO_RSA
bench_rsa();
#endif
#ifndef NO_DH
bench_dh();
#endif
#if defined(CYASSL_KEY_GEN) && !defined(NO_RSA)
bench_rsaKeyGen();
#endif
#ifdef HAVE_ECC
bench_eccKeyGen();
bench_eccKeyAgree();
#endif
return 0;
}
//
// Main application entry point.
//
int main(void)
{
static DWORD t = 0;
// Initialize application specific hardware
InitializeBoard();
//Initialize the DB_UTILS IO channel
/* Must add "PIC32_STARTER_KIT" macro definition to the project
* build options for the C compiler for debug output to work. */
DBINIT();
// Display the introduction
DBPRINTF("Smart Outlet Started\n");
fprintf(stdout, "stdout up\n");
fprintf(stderr, "stderr up\n");
// Initialize stack-related hardware components that may be
// required by the UART configuration routines
TickInit();
#if defined(STACK_USE_MPFS) || defined(STACK_USE_MPFS2)
MPFSInit();
#endif
// Initialize Stack and application related NV variables into AppConfig.
InitAppConfig();
// Initialize core stack layers (MAC, ARP, TCP, UDP) and
// application modules (HTTP, SNMP, etc.)
StackInit();
// Initialize any application-specific modules or functions/
// SmartWall Init
/* Local Temp Vars */
unsigned int i = 0;
/* Setup Temporary Processor Storage Vars */
/* Chan Storage */
struct SWChannelEntry tmpChnEntries[MYSWCHAN];
memset(&tmpChnEntries, 0, sizeof(tmpChnEntries));
struct SWChannelData tmpChnData;
memset(&tmpChnData, 0, sizeof(tmpChnData));
union outletChanArg tmpChanArgs[MYSWCHAN];
memset(&tmpChanArgs, 0, sizeof(tmpChanArgs));
tmpChnData.data = tmpChnEntries;
/* Init chanData Buffer */
for(i = 0; i < MYSWCHAN; i++){
tmpChnData.data[i].chanValue = &(tmpChanArgs[i]);
}
struct SWChannelLimits limits;
limits.maxNumChan = MYSWCHAN;
limits.maxDataLength = sizeof(*tmpChanArgs);
/* Setup Processors */
struct SWDevProcessor processors[NUMOUTLETPROCESSORS];
memset(processors, 0, sizeof(processors));
processors[0].processorScope = SW_SCP_CHANNEL;
processors[0].data = &tmpChnData;
processors[0].dataLimits = &limits;
processors[0].decoder = (readSWBody)readSWChannelBody;
processors[0].handeler = (swDevHandeler)outletChnDevHandeler;
processors[0].encoder = (writeSWBody)writeSWChannelBody;
/* Setup State Vars */
struct outletDeviceState myState;
memset(&myState, 0, sizeof(myState));
outletChanState_t chState[MYSWCHAN];
memset(&chState, 0, sizeof(chState));
outletChanPower_t chPower[MYSWCHAN];
memset(&chPower, 0, sizeof(chPower));
struct SWDeviceInfo myDevice;
memset(&myDevice, 0, sizeof(myDevice));
myState.myDev = &myDevice;
myState.chState = chState;
myState.chPower = chPower;
enum SWReceiverState machineState = RST_SETUP;
/* Setup SW Vars */
struct SWDeviceInfo tgtDevice;
myState.myDev->devInfo.swAddr = MYSWADDRESS;
myState.myDev->devInfo.devTypes = MYSWTYPE;
myState.myDev->devInfo.numChan = MYSWCHAN;
myState.myDev->devInfo.version = SW_VERSION;
myState.myDev->devInfo.uid = MYSWUID;
myState.myDev->devInfo.groupID = MYSWGROUP;
/* My IP */
myState.myDev->devIP.sin_family = AF_INET;
myState.myDev->devIP.sin_port = LISTENPORT;
myState.myDev->devIP.sin_addr.s_addr = hton32(INADDR_ANY);
tgtDevice.devIP.sin_family = AF_INET;
tgtDevice.devIP.sin_port = SENDPORT;
tgtDevice.devIP.sin_addr.s_addr = hton32(INADDR_ANY);
// Now that all items are initialized, begin the co-operative
// multitasking loop. This infinite loop will continuously
// execute all stack-related tasks, as well as your own
// application's functions. Custom functions should be added
// at the end of this loop.
// Note that this is a "co-operative mult-tasking" mechanism
// where every task performs its tasks (whether all in one shot
// or part of it) and returns so that other tasks can do their
// job.
// If a task needs very long time to do its job, it must be broken
// down into smaller pieces so that other tasks can have CPU time.
while(1)
{
// Blink LED0 (right most one) every second.
if(TickGet() - t >= TICK_SECOND/2ul)
{
t = TickGet();
LED0_IO ^= 1;
}
// This task performs normal stack task including checking
// for incoming packet, type of packet and calling
// appropriate stack entity to process it.
StackTask();
// This tasks invokes each of the core stack application tasks
StackApplications();
// Process application specific tasks here.
// Any custom modules or processing you need to do should
// go here.
machineState = swReceiverStateMachine(machineState,
myState.myDev, &tgtDevice,
&myState,
processors, NUMOUTLETPROCESSORS);
updateDeviceState(&myState);
}
}
int main(void)
{
/******************* Setup *****************************/
mPORTBSetPinsAnalogIn(0xFFFF); //Enable all analog
//mPORTDSetPinsDigitalOut(BIT_0 | BIT_1 | BIT_8);
SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);
CloseADC10();
SetChanADC10(INITCH);
OpenADC10(CONFIG1, CONFIG2, CONFIG3, CFGPORT, CFGSCAN);
ConfigIntADC10(CFGINT);
EnableADC10();
//Initialize the DB_UTILS IO channel
DBINIT();
// Display the introduction
DBPRINTF("Welcome to the PIC32 Starter Kit Tutorial.\n");
DBPRINTF("The build date and time is (" __DATE__ "," __TIME__ ")\n");
/********************* Declarations *********************/
int damper = 0; //ch1 binary read
int damperchnum = 0; //damper adc number
int hammerchnum = 1; //hammer adc number
int samplesize = 1000;
int hammerdata[10][samplesize]; //collection of hammer values
int damperdata[10][samplesize]; //collection of damper values
int index = 0; //index of hammerdata and damperdata arrays
int collection[2] = {0,0};
int count = 0;
/******************** Initialize Arrays ******************/
int x;
int y;
for( x = 0; x < 10; x++)
{
for( y = 0; y < samplesize; y++)
{
damperdata[x][y] = 0;
}
}
/************************ Stuff to do *********************/
while (count < 4){
damper = ReadADC10(damperchnum);
if(damper > 100)
{
//store data
collection[0] = collection[1]; //we are collecting data, falling edge detection
collection[1] = 1;
if(index<samplesize)
{
hammerdata[count][index] = ReadADC10(hammerchnum);
damperdata[count][index] = damper;
index++;
//DBPRINTF("Damper: %d \n", damperdata[count][index-1]);
}
}else{
collection[0] = collection[1];
collection[1] = 0;
}
if(collection[1] < collection[0]) //rising edge detection
{
DBPRINTF("Count: %d \n", count);
count++;
index = 0;
}
}
int i;
/******************** Output Memory at End **********************/
for( i = 0; i < 1000; i++)
{
DBPRINTF("Damper data: %d ", damperdata[1][i]);
DBPRINTF("\n");
}
return 0;
}