void main(void) {
unsigned long numSectors;
/* init interrupts */
initInterrupts();
/* check disk ready */
if (!checkDiskReady()) {
error("disk not ready");
}
/* determine disk size */
numSectors = getDiskSize();
printf("Disk has %lu (0x%lX) sectors.\n",
numSectors, numSectors);
if (numSectors < 32) {
error("disk is too small");
}
/* copy boot block to write buffer */
copyBootBlock();
/* write boot block to disk */
printf("Writing boot block to disk...\n");
if (!writeDisk(0, 32, wrBuf)) {
error("cannot write boot block to disk");
}
/* done */
printf("Halting...\n");
}
int main(void) {
unsigned char errorCode = NO_ERROR;
//initialization
errorCode = initIOPorts();
errorCode = initSREGFlags();
errorCode = initInterrupts();
FOREVER {
if(lightBarState != OFF) {
lightBarState = pollJoystickSignals(lightBarState);
switch(lightBarState) {
case UP: if(lightBar == 0x80) lightBar = 0x01;
else lightBar <<= 1;
break;
case DOWN: if(lightBar == 0x01) lightBar = 0x80;
else lightBar >>= 1;
break;
default: break;
}
_delay_ms(300);
}
PORTL = lightBar;
}
int main(void) {
unsigned char c;
int n;
printf("Keyboard Test:\n");
printf("initializing interrupts...\n");
initInterrupts();
printf("setting kbd ISR...\n");
setISR(4, kbdISR);
printf("enabling kbd interrupt mask bit...\n");
setMask(getMask() | (1 << 4));
printf("enabling interrupts in kbd controller...\n");
kbdEnable();
n = 0;
while (1) {
while (charAvail == 0) ;
disable();
c = charRead;
charAvail = 0;
enable();
printf("%02X ", c);
if (++n == 24) {
n = 0;
printf("\n");
}
}
return 0;
}
int main()
{
init_platform();
initInterrupts();
int source_word[16];
int destination_word[16];
setArray(source_word, 16, 0);
setArray(destination_word, 16, 1);
printf("Printing value before DMA transfer.\n\r");
printArray(destination_word, 16);
DMA_CONTROLLER_InitiateTransfer(XPAR_DMA_CONTROLLER_0_BASEADDR, (Xuint32) &source_word, (Xuint32) &destination_word, 4 * 10);
printf("Printing value after DMA transfer.\n\r");
printArray(destination_word, 16);
setArray(source_word, 6, 1);
DMA_CONTROLLER_InitiateTransfer(XPAR_DMA_CONTROLLER_0_BASEADDR, (Xuint32) &source_word, (Xuint32) &destination_word, 4 * 10);
printf("Printing value after 2nd DMA transfer.\n\r");
printArray(destination_word, 16);
cleanup_platform();
return 0;
}
void measinit(void) {
cycleData.intFlag = 0;
cycleData.Cnt = 0;
initWheelData();
initPorts();
initTimers();
initInterrupts();
}
// returns the timer handle (hTimer)
unsigned StartKernelTimer (unsigned nHzDelay, TKernelTimerHandler *pHandler, void *pParam, void *pContext) {
if(interrupt->ENABLE_BASIC_IRQ != 1) {initInterrupts(); interruptBasicIRQ();}
enableTimeout(40, RPI_ARMTIMER_CTRL_23BIT | RPI_ARMTIMER_CTRL_ENABLE | RPI_ARMTIMER_CTRL_INT_ENABLE | RPI_ARMTIMER_CTRL_PRESCALE_256);
pHandler(1, pParam, pContext);
return 1;
}
int main() {
DWORD t = 0;
//Needed because a bug in picc-18?
MIWRL=0;
MIWRH=0;
TRISA = 0;
TRISB = 0;
TRISC = 0;
TRISD = 0;
TRISE = 0;
TRISF = 0;
TRISG = 0;
PORTA=0;
PORTB=0;
PORTC=0;
PORTD=0;
PORTE=0;
PORTF=0;
OSCTUNE = 0x40; //Speed up to 41.67 MHz
//Turn off AD
ADCON1 = 0x0F;
#if defined(DEBUG) && defined(_18F87J60)
initUsart2();
#endif
initTransmitter();
initReceiver();
initPwm();
initInterrupts();
initAppConfig();
initWDT();
TickInit();
StackInit();
//Set the LED on the connector
SetLEDConfig(0x3742); //See MAC.h for the values
printf("Telldus TellStick Net v%s\r\n", FIRMWARE_VERSION);
while(1) {
StackTask();
StackApplications();
if(TickGet() - t >= TICK_SECOND) {
t = TickGet();
}
#if defined(DEBUG)
debugTask();
#endif
rfReceiveTask();
discoveryTask();
ClrWdt();
}
return 42;
}
/** @brief The main top level init
*
* The main init function to be called from main.c before entering the main
* loop. This function is simply a delegator to the finer grained special
* purpose init functions.
*
* @author Fred Cooke
*/
void init(){
ATOMIC_START(); /* Disable ALL interrupts while we configure the board ready for use */
initPLL(); /* Set up the PLL and use it */
initIO(); /* TODO make this config dependent. Set up all the pins and modules to be in low power harmless states */
initAllPagedRAM(); /* Copy table and config blocks of data from flash to the paged ram blocks for fast data lookup */
initAllPagedAddresses(); /* Save the paged memory addresses to variables such that we can access them from another paged block with no warnings */
initVariables(); /* Initialise the rest of the running variables etc */
initFlash(); /* TODO, finalise this */
initECTTimer(); /* TODO move this to inside config in an organised way. Set up the timer module and its various aspects */
initPITTimer(); /* TODO ditto... */
initSCIStuff(); /* Setup the sci module(s) that we will use. */
initConfiguration(); /* TODO Set user/feature/config up here! */
initInterrupts(); /* still last, reset timers, enable interrupts here TODO move this to inside config in an organised way. Set up the rest of the individual interrupts */
ATOMIC_END(); /* Re-enable any configured interrupts */
}
int main(int argc, char* argv[], char* envp[])
{
printf("Started\n");
initOSDataStructs();
printf("Init structs\n");
initInterrupts();
printf("Init interrupts\n");
initVGA();
printf("Init vga\n");
initCreateTasks();
printf("Init tasks\n");
vTaskStartScheduler();
printf("Init scheduler\n");
for (;;);
return 0;
}
int main(void) {
cli();
cycleData.intFlag = 0;
cycleData.Cnt = 0;
initWheelData();
initPorts();
initTimers();
initUSART();
initInterrupts();
sei();
for(;;) {
if(cycleData.intFlag)
prgm800Hz();
if(cycleData.Cnt == 8)
prgm100Hz();
}
}
Sensorik::Sensorik() {
initInterrupts();
// create channel for dispatcher
sensorik_Chid = ChannelCreate(0);
if (sensorik_Chid == -1) {
perror("Dispatcher: ChannelCreate sensorik_Chid failed");
exit(EXIT_FAILURE);
}
// attach to signal channel(stellt die verbindung zu dem channel des Prozesses PID)
sensorik_Coid = ConnectAttach(0, 0, sensorik_Chid, _NTO_SIDE_CHANNEL, 0);
if (sensorik_Coid == -1) {
perror("SensorCtrl: ConnectAttach sensorik_Coid failed");
exit(EXIT_FAILURE);
}
}
int main(void) {
uint8_t oldStatus = 0;
initSysVars();
initPorts();
// we use RS485 here, to go with RS232 just have a look at Modbus_uart.c/.h
// and use the rs232 init function
rs485_init(UART_BAUD_SELECT(9600,F_CPU));
initInterrupts();
sei();
// actProfileData[IDX_DW_Debug02] = 2;
actProfileData[IDX_DW_Debug01] = 101;
actProfileData[IDX_DW_Debug02] = 102;
actProfileData[IDX_DW_Debug03] = 103;
actProfileData[IDX_DW_EncSteps] = 200;
actProfileData[IDX_DW_EncHyst] = 4;
setBitValForSysBit(IDX_AB_EncSync, ON);
for (;;) {
if (oldStatus != uart0_status.status) {
oldStatus = uart0_status.status;
if (uart0_status.status == RS_FrameComplete) {
if (UART_RxHead) {
modbus_processSlaveFrame((uint8_t*) UART_RxBuf, UART_RxHead);
}
uart_flush();
uart0_status.status = RS_Wait;
}
}
if (changedBit.cBit != 99) {
performBitActions();
}
}
}
int main()
{
initTimers();
initVideo();
sound_initAC97();
mouse_init();
initInterrupts();
isNewGame = true;
initGameScreen();
PIT_startRecurringTimer(XPAR_PIT_0_BASEADDR, CLOCK_FREQ_HZ / INTERRUPTS_PER_SECOND);
while(1) // Program never ends.
if(low_priority_intc_status != 0)
lowPriorityInterruptHandler();
cleanup_platform();
return 0;
}
/** @brief The main top level init
*
* The main init function to be called from main.c before entering the main
* loop. This function is simply a delegator to the finer grained special
* purpose init functions.
*/
void init(){
ATOMIC_START(); /* Disable ALL interrupts while we configure the board ready for use */
initPLL(); /* Set up the PLL and use it */
initGPIO();
initPWM();
initADC();
initAllPagedRAM(); /* Copy table and config blocks of data from flash to the paged RAM blocks for fast data lookup */
initVariables(); /* Initialise the rest of the running variables etc */
initFlash(); /* TODO, finalise this */
initECTTimer(); /* TODO move this to inside config in an organised way. Set up the timer module and its various aspects */
// initPITTimer(); /* TODO ditto... */
initSCIStuff(); /* Setup the sci module(s) that we will use. */
initConfiguration(); /* TODO Set user/feature/config up here! */
#ifdef XGATE
initXgate(); /* Fred is a legend, for good reason as of now */
#endif
initInterrupts(); /* still last, reset timers, enable interrupts here TODO move this to inside config in an organised way. Set up the rest of the individual interrupts */
ATOMIC_END(); /* Re-enable any configured interrupts */
}
/**
Add an interrupt handler for this signal.
If you want to get notified when the signal on this pin changes,
you can register an interrupt handler, instead of constantly reading the pin.
To do this, define a function you want to be called when the pin changes, and
then register it with the Io you want to monitor. The function has to have a
specific signature - it must be of the form:
\code void myHandler(void* context) \endcode
This function will be called any time the signal on the Io pin changes. When you
register the handler, you can provide a pointer to some context that will be passed
into your handler. This can be an instance of a class, if you want to
\b Example
\code
void myHandler(void* context); // declare our handler
void myTask(void* p)
{
Io io(IO_PB27, Io::GPIO, INPUT); // Io on AnalogIn 0 - as digital input
io.addInterruptHandler(myHandler); // register our handler
while(true)
{
// do the rest of my task...
}
}
int count = 0; // how many times has our interrupt triggered?
// now this will get called every time the value on PB27 changes
void myHandler(void* context)
{
count++;
if(count > 100)
count = 0;
}
\endcode
@param h The function to be called when there's an interrupt
@param context (optional) Context that will be passed into your handler, if desired.
@return True if the handler was registered successfully, false if not.
*/
bool Io::addInterruptHandler(handler h, void* context)
{
if(isrSourceCount >= MAX_INTERRUPT_SOURCES)
return false;
isrSources[isrSourceCount].port = basePort;
isrSources[isrSourceCount].mask = mask;
// if this is the first time for either channel, set it up
if( (!isrAInit && basePort == AT91C_BASE_PIOA) ||
(!isrBInit && basePort == AT91C_BASE_PIOB) )
{
initInterrupts(basePort, (AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL | 3) );
}
basePort->PIO_ISR; // clear the status register
basePort->PIO_IER = isrSources[isrSourceCount].mask; // enable our channel
isrSources[isrSourceCount].handler = h;
isrSources[isrSourceCount++].context = context; // make sure to increment our handler count
return true;
}
int main(void) {
int error = NO_ERROR;
error = initIOPorts();
error = initADC();
error = initTimer();
error = initInterrupts();
FOREVER {
ADCSRA |= 0x40;
while(ADCSRA & 0x40) {}
adResult = ADCH;
// mindestens 32 als ergebnis festlegen
// ergebnis wird als top wert fuer timer benutzt
if(adResult < 32) adResult = 32;
}
return error;
}
int main(void) {
uint8_t payload[ADVLEN];
//Disable JTAG to allow for Standby
AONWUCJtagPowerOff();
//Force AUX on
powerEnableAuxForceOn();
powerEnableRFC();
powerEnableXtalInterface();
// Divide INF clk to save Idle mode power (increases interrupt latency)
powerDivideInfClkDS(PRCM_INFRCLKDIVDS_RATIO_DIV32);
initRTC();
powerEnablePeriph();
powerEnableGPIOClockRunMode();
/* Wait for domains to power on */
while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON));
sensorsInit();
ledInit();
//Config IOID4 for external interrupt on rising edge and wake up
//IOCPortConfigureSet(BOARD_IOID_KEY_RIGHT, IOC_PORT_GPIO, IOC_IOMODE_NORMAL | IOC_FALLING_EDGE | IOC_INT_ENABLE | IOC_IOPULL_UP | IOC_INPUT_ENABLE | IOC_WAKE_ON_LOW);
// Config reedSwitch as input
IOCPortConfigureSet(BOARD_IOID_DP0, IOC_PORT_GPIO, IOC_IOMODE_NORMAL | IOC_RISING_EDGE | IOC_INT_ENABLE | IOC_IOPULL_DOWN | IOC_INPUT_ENABLE | IOC_WAKE_ON_HIGH);
//Set device to wake MCU from standby on PIN 4 (BUTTON1)
HWREG(AON_EVENT_BASE + AON_EVENT_O_MCUWUSEL) = AON_EVENT_MCUWUSEL_WU0_EV_PAD; //Does not work with AON_EVENT_MCUWUSEL_WU0_EV_PAD4 --> WHY??
IntEnable(INT_EDGE_DETECT);
powerDisablePeriph();
//Disable clock for GPIO in CPU run mode
HWREGBITW(PRCM_BASE + PRCM_O_GPIOCLKGR, PRCM_GPIOCLKGR_CLK_EN_BITN) = 0;
// Load clock settings
HWREGBITW(PRCM_BASE + PRCM_O_CLKLOADCTL, PRCM_CLKLOADCTL_LOAD_BITN) = 1;
initInterrupts();
initRadio();
// baek: before while
powerEnablePeriph();
powerEnableGPIOClockRunMode();
/* Wait for domains to power on */
while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON)); // CRASH !!!!!!!!!!!!!!
sensorsInit();
ledInit();
// end baek:
// Turn off FLASH in idle mode
powerDisableFlashInIdle();
// Cache retention must be enabled in Idle if flash domain is turned off (to avoid cache corruption)
powerEnableCacheRetention();
//AUX - request to power down (takes no effect since force on is set)
powerEnableAUXPdReq();
powerDisableAuxRamRet();
//Clear payload buffer
memset(payload, 0, ADVLEN);
while(1) {
//if((g_count& 0x04)== 1){
rfBootDone = 0;
rfSetupDone = 0;
rfAdvertisingDone = 0;
select_bmp_280(); // activates I2C for bmp-sensor
enable_bmp_280(1); // works
//Wait until RF Core PD is ready before accessing radio
waitUntilRFCReady();
initRadioInts();
runRadio();
//Wait until AUX is ready before configuring oscillators
waitUntilAUXReady();
//Enable 24MHz XTAL
OSCHF_TurnOnXosc();
//IDLE until BOOT_DONE interrupt from RFCore is triggered
while( ! rfBootDone) {
powerDisableCPU();
PRCMDeepSleep();
}
//This code runs after BOOT_DONE interrupt has woken up the CPU again
// ->
//Request radio to keep on system bus
radioCmdBusRequest(true);
//Patch CM0 - no RFE patch needed for TX only
radioPatch();
//Start radio timer
radioCmdStartRAT();
//Enable Flash access while doing radio setup
powerEnableFlashInIdle();
//Switch to XTAL
while( !OSCHF_AttemptToSwitchToXosc())
{}
/* baek: before while
powerEnablePeriph();
powerEnableGPIOClockRunMode();
/* Wait for domains to power on */
/* while((PRCMPowerDomainStatus(PRCM_DOMAIN_PERIPH) != PRCM_DOMAIN_POWER_ON)); // CRASH !!!!!!!!!!!!!!
sensorsInit();
ledInit();
*/
/*****************************************************************************************/
// Read sensor values
uint32_t pressure = 0; // only 3 Bytes used
//uint32_t temp = 0;
select_bmp_280(); // activates I2C for bmp-sensor
enable_bmp_280(1); // works
do{
pressure = value_bmp_280(BMP_280_SENSOR_TYPE_PRESS); // read and converts in pascal (96'000 Pa)
//temp = value_bmp_280(BMP_280_SENSOR_TYPE_TEMP);
}while(pressure == 0x80000000);
if(pressure == 0x80000000){
CPUdelay(100);
pressure = value_bmp_280(BMP_280_SENSOR_TYPE_PRESS); // read and converts in pascal (96'000 Pa)
}
//Start Temp measurement
uint16_t temperature;
enable_tmp_007(1);
//Wait for, read and calc temperature
{
int count = 0;
do{
temperature = value_tmp_007(TMP_007_SENSOR_TYPE_AMBIENT);
//g_count++;
}while( ((temperature == 0x80000000) || (temperature == 0)) && (count <=5) );
count++;
count--;
}
enable_tmp_007(0);
char char_temp[2];
//start hum measurement
configure_hdc_1000();
start_hdc_1000();
// //Wait for, read and calc humidity
while(!read_data_hdc_1000());
int humidity = value_hdc_1000(HDC_1000_SENSOR_TYPE_HUMIDITY);
// char char_hum[5];
//END read sensor values
/*****************************************************************************************/
powerDisablePeriph();
// Disable clock for GPIO in CPU run mode
HWREGBITW(PRCM_BASE + PRCM_O_GPIOCLKGR, PRCM_GPIOCLKGR_CLK_EN_BITN) = 0;
// Load clock settings
HWREGBITW(PRCM_BASE + PRCM_O_CLKLOADCTL, PRCM_CLKLOADCTL_LOAD_BITN) = 1;
/*****************************************************************************************/
// Set payload and transmit
uint8_t p;
p = 0;
/*jedes 5.te mal senden*/
payload[p++] = ADVLEN-1; /* len */
payload[p++] = 0x03;
payload[p++] = 0xde;
payload[p++] = 0xba;
payload[p++] =(sequenceNumber >> 8); // laufnummer
payload[p++] = sequenceNumber;
// Speed
payload[p++] = g_diff >> 24; // higher seconds
payload[p++] = g_diff >> 16; // lower seconds
payload[p++] = g_diff >> 8; // higher subseconds
payload[p++] = g_diff; // lower subseconds
//pressure
payload[p++] = 0;
payload[p++] = 0; //(pressure >> 16);
payload[p++] = 0; //(pressure >> 8);
payload[p++] = 0; //pressure;
//temperature
payload[p++] = 0;
payload[p++] = 0; // char_temp[2];
payload[p++] = 0;//temperature >> 8; // char_temp[1];
payload[p++] = 0; //temperature; //char_temp[0];
// huminity
payload[p++] = 0;
payload[p++] = 0;//char_hum[0];
payload[p++] = 0;//char_hum[1];
payload[p++] = 0;//char_hum[2];
payload[p++] = 0;
payload[p++] = 0;
//Start radio setup and linked advertisment
radioUpdateAdvData(ADVLEN, payload);
//Start radio setup and linked advertisment
radioSetupAndTransmit();
//}
//END: Transmit
/*****************************************************************************************/
//Wait in IDLE for CMD_DONE interrupt after radio setup. ISR will disable radio interrupts
while( ! rfSetupDone) {
powerDisableCPU();
PRCMDeepSleep();
}
//Disable flash in IDLE after CMD_RADIO_SETUP is done (radio setup reads FCFG trim values)
powerDisableFlashInIdle();
//Wait in IDLE for LAST_CMD_DONE after 3 adv packets
while( ! rfAdvertisingDone) {
powerDisableCPU();
PRCMDeepSleep();
}
//Request radio to not force on system bus any more
radioCmdBusRequest(false);
// } // end if
// g_count++;
//
// Standby procedure
//
powerDisableXtal();
// Turn off radio
powerDisableRFC();
// Switch to RCOSC_HF
OSCHfSourceSwitch();
// Allow AUX to turn off again. No longer need oscillator interface
powerDisableAuxForceOn();
// Goto Standby. MCU will now request to be powered down on DeepSleep
powerEnableMcuPdReq();
// Disable cache and retention
powerDisableCache();
powerDisableCacheRetention();
//Calculate next recharge
SysCtrlSetRechargeBeforePowerDown(XOSC_IN_HIGH_POWER_MODE);
// Synchronize transactions to AON domain to ensure AUX has turned off
SysCtrlAonSync();
//
// Enter Standby
//
powerDisableCPU();
PRCMDeepSleep();
SysCtrlAonUpdate();
SysCtrlAdjustRechargeAfterPowerDown();
SysCtrlAonSync();
//
// Wakeup from RTC, code starts execution from here
//
powerEnableRFC();
powerEnableAuxForceOn();
//Re-enable cache and retention
powerEnableCache();
powerEnableCacheRetention();
//MCU will not request to be powered down on DeepSleep -> System goes only to IDLE
powerDisableMcuPdReq();
}
}
/* Main Function */
int main( int argc, char *argv[] )
{
//Color constants' initilizations
BLACK = makeColour( 0, 0, 0 );
WHITE = makeColour(63,63,63 );
RED = makeColour(63, 0, 0 );
GREEN = makeColour( 0,63, 0 );
BLUE = makeColour( 0, 0,63 );
//Initializations
initInterrupts();
initScreen();
initChars();
//Enable Interrupts
enableBalloonIRQ(1000*ONE_MS, balloonISR );
int keys_to_watch = 0x04 | 0x02 ;
enableKeyIRQ( keys_to_watch, keyISR );
// fillScreen(BLACK);
int i = 0;
welcomeMessage();
mouse_status = resetPS2();
int left, right;
int lastTime;
while(1)
{
//in case of losing (past 20 misses)
if(missed >= MAX_MISS)
{
disableInterrupt(IRQ_COUNTER);
fillScreen(RED);
emptyScreen();
printStr(10, 10, "Too many misses...");
printStr(14, 13, "GAME OVER!");
printStr(8, 16, "Press KEY2 to restart");
for(i = 0; i < 30000000; i++);
// while(missed >= 20);
// printStr(8, 20, "HOOOOOORAY");
enableInterrupt(IRQ_COUNTER);
printStr(10, 10, " ");
printStr(14, 13, " ");
printStr(8, 16, " ");
}
drawChar (1, 6, ' ');
disableInterrupt(IRQ_COUNTER);
if (*pSWITCH != 0)
{
if (*pSWITCH&1)
{
increment = 1;
circleRad = 30;
}
else if (*pSWITCH&2)
{
increment = 2;
circleRad = 20;
}
else if (*pSWITCH&4)
{
increment = 3;
circleRad = 15;
}
}
else
{
increment = 1;
circleRad = 30;
}
enableInterrupt(IRQ_COUNTER);
/// MUSIC PLAYER ///
// drawChar (1, 5, 16);
if(musicCounter == 0)
{
left = 0;
right = 1;
}
if(musicCounter < musicLength/4)
{
i = musicCounter;
for(i; i<musicCounter+200; i++)
{
playMusic(music[left], music[right]);
left+=2;
right+=2;
}
musicCounter += 200;
}
else
{
musicCounter = 0;
left = 0;
right = 1;
}
/// MUSIC ///
if ( mouse_status == PS2_MOUSE )
{
// drawChar (1, 5, 22);
if( getMouseMotion( &dxMouse, &dyMouse, &mouse_button ) )
{
if( mouse_button & MOUSE_BUTTON1 )
{
if(getColor(xMouse+1, yMouse) == RED)
{
score += increment;
drawCircle(xCircle, yCircle, 30, BLACK);
/// SOUND EFFECT ///
int sleft = 0;
int sright = 1;
int i;
for(i=0; i<effectLength/4; i++)
{
playMusic(effect[sleft], effect[sright]);
sleft+=2;
sright+=2;
}
sleft = 0;
sright = 1;
/// SOUND EFFECT ///
}
else
{
if(time != lastTime)
{
missed++;
time = lastTime;
}
}
}
/* if( mouse_button & MOUSE_BUTTON2 )
fillScreen( BLACK );
if( mouse_button & MOUSE_BUTTON3 )
{
printStr(17, 13, "PAUSED!");
disableInterrupts(IRQ_COUNTER);
while( 1 )
{
if( mouse_button & MOUSE_BUTTON2 )
{
enableInterrupts(IRQ_COUNTER);
printStr(17, 13, " ");
break;
}
}
}
*/
if(getColor(xMouse+1, yMouse) == RED)
dragColor = RED;
else
dragColor = BLACK;
drawPixel( xMouse, yMouse, dragColor );
xMouse += dxMouse;
yMouse -= dyMouse;
xMouse = max( 0, min( xMouse, MAX_X_PIXELS-1 ) );
yMouse = max( 0, min( yMouse, MAX_Y_PIXELS-1 ) );
drawPixel( xMouse, yMouse, WHITE );
//drawCursor(xMouse, yMouse);
}
}
}
return 0;
}
int main(void)
{
initUART(UBBR);
printf("Simple RAM TEST \r\n");
initExtMemIface();
initTimer();
initInterrupts();
SRAM_test();
joyInit();
initOLED();
initSPI();
initCAN(NORMAL);
struct joypos_t p;
enum joydir_t d;
struct canMessage m0,m1,m2s;
while(1){
/* slide1Point=getSlidePosition(1);
slide2Point=getSlidePosition(2);
printf("SLIDE1 -> %d",slide1Point.x);
printf("SLIDE2 -> %d",slide2Point.x);SLIDE READINGS*/
if (readControl) {
readControl = 0;
d = getJoyDirection();
p = getJoyPosition();
sendCANJoy(2,p,d);
if (d == TOP || d == RIGHT_TOP || d == LEFT_TOP) menuOption = (menuOption-1)%NUM_MENU_OPTIONS;
else if (d == BOTTOM || d == RIGHT_BOTTOM|| d == LEFT_BOTTOM) menuOption = (menuOption+1)%NUM_MENU_OPTIONS;
printMenu(menuOption);
}
if (flagJoyButton) {
m2s.id = JOY_BUTTON;
m2s.size = 0;
printf("Sending joy bu\r\n");
fillTxBufferMCP(0,m2s);
requestToSendMCP(0);
struct canMessage m2s;
flagJoyButton = 0;
gotoCharOLED(7,0);
putsOLED(" "); //Cleans last selected option from screen
switch(menuOption){
case 0: //Play
gotoCharOLED(7,0);
putsOLED("PLAY");
break;
case 1: //Options
gotoCharOLED(7,0);
putsOLED("OPTIONS");
break;
case 2: //Help
printHelp();
break;
default:
gotoCharOLED(7,0);
putsOLED("Stick to the OPTIONS !!!");
break;
}
}
/*
if(flagMCP) {
flagMCP = 0;
struct canMessage m0,m1;
m0 = readRxBufferMCP(0);
m1 = readRxBufferMCP(1);
printf ("Buffer 0 ID: %d, Size: %d, Data: %s \r\n", m0.id, m0.size, m0.data);
printf ("Buffer 1 ID: %d, Size: %d, Data: %s \r\n", m1.id, m1.size, m1.data);
}*/
}
}
/*******************************************************************************
* main()
*
* Description:
* Main application code
*
* See also:
*
* Arguments:
* void
*
* Returns:
* void
*
* Callers: C start-up code
*
* Notes :
*
*******************************************************************************/
int main(void)
{
CBUFFNUM testBufferNum;
CBUFFNUM uartOutBufferNum;
volatile unsigned int x = 0;
/* Initialise all used hardware and */
/* related interrupts */
initLEDs();
initUart2();
initTimer2();
initInterrupts();
termInit();
/* Create circular buffers */
cbuffInit();
testBufferNum = cbuffCreate(testBuffer, TESTBUFFERSIZE,
&testBufferObj);
uartOutBufferNum = cbuffCreate(uartOutBuffer, UARTOUTBUFFERSIZE,
&uartOutBufferObj);
/* Check buffers were created */
if (testBufferNum == 0 || uartOutBufferNum == 0)
{
error();
}
/* Get handles to buffers */
hTestBuffer = cbuffOpen(testBufferNum);
hUartOutBuffer = cbuffOpen(uartOutBufferNum);
/* Check buffers were opened */
if (hTestBuffer == (HCBUFF) 0 || hUartOutBuffer == (HCBUFF) 0)
{
error();
}
/* Start Timer based data generation */
startTimer2();
/* Output statistics */
while(1)
{
triggerUART2(hUartOutBuffer);
updateStats(hTestBuffer);
//termOutput(hUartOutBuffer);
if(termIsAutomatic())
{
if(cbuffGetSpace(hTestBuffer) <= termGetEmptyTrigger())
{
termCheckBuffer(hTestBuffer);
termFullScreenUpdate();
}
}
else if(emptyBuffer == 1)
{
emptyBuffer = 0;
termCheckBuffer(hTestBuffer);
termFullScreenUpdate();
}
if (x >= 0x0FFF)
{
termOutput(hUartOutBuffer);
x = 0;
}
else
{
x++;
}
}
}
int main()
{
long int savedfreq = 0;
int s, c;
unsigned char sw=0;
// PORTB output for LCD
DDRB = 0xff;
PORTB = 0xff;
#ifdef BOARD2
// PORTC PC0-4 output, PC5 input
DDRC = 0x1f;
PORTC = 0x00;
sbi(PORTC, MUTE);
#endif
#ifdef BOARD1
// PORTC PC0,2-5 output, PC1 input
DDRC = 0x3d;
PORTC = 0x00;
sbi(PORTC, MUTE);
#endif
// PORTD is input with pullup
DDRD = 0x00;
PORTD = 0xff;
initLcd();
initADC();
// set reference freq
fref = eeprom_read_word((unsigned int *)0x00);
if (fref < 2000 || (fref % 100) != 0) {
fref = 12000;
eeprom_write_word((unsigned int *)0x00, fref);
}
// read squelch level from eeprom
muteval = eeprom_read_word((unsigned int *)0x0c);
if (muteval < 0 || muteval > 100) {
muteval = 0;
eeprom_write_word((unsigned int *)0x0c, muteval);
}
// read last frequency from eeprom
freq = eeprom_read_dword((unsigned long int *)0x10);
if (freq < 1240000UL || freq > 1300000UL) {
freq = 1298375UL;
eeprom_write_dword((unsigned long int *)0x10, freq);
}
// read shift from eeprom
shift = eeprom_read_word((unsigned int *)0x18);
if (shift < 60000UL || shift > 60000UL) {
shift = -28000UL;
eeprom_write_word((unsigned int *)0x18, shift);
}
// read tone (*10) from eeprom
tone = eeprom_read_word((unsigned int *)0x1c);
if (tone < 650 || tone > 1500) {
tone = 650;
eeprom_write_word((unsigned int *)0x1c, tone);
}
initInterrupts();
initPLL(freq - IF);
update();
sprintf(str, "JPD 23cm v%s", version);
lcdCmd(0x80);
lcdStr(str);
_delay_ms(500);
for (;;) {
lcdCmd(0x80);
lcdStr("VFO ");
lcdCmd(0xc0);
lcdStr(" ");
update();
for (;;) {
// read switches on PORTD
sw = PIND;
// switch from tx to rx??
if (tx && (sw & (1<<PTT) )) {
cbi(PORTC, TXON);
// switch TX off
tx = FALSE;
// TCCR2A &= ~(1<<COM2A1);
update();
}
// switch from rx to tx?
else if (!tx && !(sw & (1<<PTT) )) {
tx = TRUE;
displaySmeter(0);
// switch TX on
sbi(PORTC, TXON);
sbi(PORTC, MUTE);
// if (tone > 650) {
// TCCR2A |= (1<<COM2A1);
// }
update();
}
if (!tx) {
s = readSmeter();
displaySmeter(s);
if (s > muteval)
cbi(PORTC, MUTE);
else
sbi(PORTC, MUTE);
}
// switch shift off
if ( (shiftSwitch == TRUE) && (sw & (1<<SHIFTKEY) )) {
shiftSwitch = FALSE;
update();
}
// switch shift on
else if ( (shiftSwitch == FALSE) && !(sw & (1<<SHIFTKEY) )) {
shiftSwitch = TRUE;
update();
}
// save vfo frequency in eeprom after ~2 secs inactivity
if (tick > 200) {
if (freq != savedfreq) {
eeprom_write_dword((unsigned long int *)0x10, freq);
savedfreq = freq;
}
}
// handle encoder pulses
c = handleRotary();
if (c!=0) {
if (c>0) {
freq += step;
}
else {
freq -= step;
}
tick = 0;
update();
}
if (rotaryPushed()) {
doMenu();
break;
}
}
}
}
int main(void) {
uint8_t numSensors = 0, i;
// unsigned long nextflash = 0;
// Configure all pins as inputs with pullups initially
DDRA = 0x00;
PORTA = 0xff;
DDRB = 0x00;
PORTB = 0xff;
// Serial output line
DDRB |= _BV(PINB0);
PORTB |= _BV(PINB0);
// LED
// DDRA |= _BV(PINA0);
// Radio power is PA1
PORTA &= ~_BV(PINA1);
DDRA |= _BV(PINA1);
// Onewire power is PA2
PORTA &= ~_BV(PINA2);
DDRA |= _BV(PINA2);
myPutStr("Hello world\r\n");
// Various power-saving things
// Disable BOD while sleeping. I hope.
MCUCR |= (_BV(BODS) | _BV(BODSE));
MCUCR &= ~_BV(BODSE);
MCUCR |= (_BV(BODS));
// Disable the ADC
ADCSRA &= ~_BV(ADEN);
// Disable the Analog Comparator
ACSR |= _BV(ACD);
// Disable clocking of timer1 and ADC
PRR |= (_BV(PRTIM1)|_BV(PRADC));
timerInit();
wdtInit();
initInterrupts();
// Power up the Onewire bus
PORTA |= _BV(PINA2);
while(numSensors == 0) {
myPutStr("Scanning for sensors\r\n");
numSensors = search_sensors();
myPutStr("Found ");
myPutUint8(numSensors);
myPutStr(" sensors\r\n");
for (i=0;i<numSensors;i++) {
uint8_t j;
myPutStr("Sensor ");
myPutUint8(i);
myPutStr(" address ");
for (j=0;j<OW_ROMCODE_SIZE;j++) {
myPutUint8(gSensorIDs[i][j]);
}
if (gSensorIDs[i][0] == DS18S20_FAMILY_CODE ) {
myPutStr(" DS18S20/DS1820");
} else if ( gSensorIDs[i][0] == DS1822_FAMILY_CODE ) {
myPutStr(" DS1822");
} else {
myPutStr(" DS18B20");
}
if ( DS18X20_get_power_status( &gSensorIDs[i][0] ) == DS18X20_POWER_PARASITE ) {
myPutStr(" parasite\r\n");
} else {
myPutStr(" external\r\n");
}
// Enable 12 bit mode (won't do anything on DS18S20)
DS18X20_write_scratchpad(&gSensorIDs[i][0], 0, 0, DS18B20_12_BIT);
DS18X20_scratchpad_to_eeprom(DS18X20_get_power_status( &gSensorIDs[i][0] ),&gSensorIDs[i][0]);
}
}
while(1) {
unsigned long wakepoint;
myRadioBuf_t radiobuf;
//char debugbuf[10];
// if ((signed long)now - (signed long)nextflash >= 0) {
// debugLedToggle(0);
// nextflash = now + 1000;
// }
// Power up the Onewire bus
PORTA |= _BV(PINA2);
// Let is stabilize for a few ms
wakepoint = getMillis() + 15;
numSensors = search_sensors();
while (! ((signed long)getMillis() - (signed long)wakepoint >= 0)) {
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode();
}
if ( DS18X20_start_meas( DS18X20_POWER_PARASITE, NULL ) == DS18X20_OK) {
wakepoint = getMillis() + DS18B20_TCONV_12BIT;
while (! ((signed long)getMillis() - (signed long)wakepoint >= 0)) {
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode();
}
// Power the radio up
PORTA |= _BV(PINA1);
// Wakepoint set to now +100ms to allow radio to wake
wakepoint = getMillis() + 100;
for ( i = 0; i < numSensors; i++ ) {
radiobuf.tenthousandths = -9999999L;
if (DS18X20_read_maxres( &gSensorIDs[i][0], &(radiobuf.tenthousandths) ) != DS18X20_OK) {
radiobuf.tenthousandths = -9999999L;
}
//myPutStr("Sensor ");
uint8_t j;
for (j=0;j<OW_ROMCODE_SIZE;j++) {
radiobuf.sensid[j] = gSensorIDs[i][j];
//myPutUint8(gSensorIDs[i][j]);
}
//myPutStr(" = ");
//sprintf(debugbuf, "%d.%d\r\n", (int)(radiobuf.tenthousandths/10000), (int)(radiobuf.tenthousandths % 10000));
//myPutStr(debugbuf);
if (0 == i) {
// First time around, radio not initialized
while (! ((signed long)getMillis() - (signed long)wakepoint >= 0)) {
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_mode();
}
radioInit();
// No auto ack
radioSetAutoAck(0);
radioOpenWritingPipe(pipe);
}
radiobuf.tstamp = getMillis();
//myPutStr("about to radioWrite, i=");
//myPutUint8(i);
//myPutStr("...");
radioWrite(&radiobuf,sizeof(radiobuf));
//myPutStr("Done\r\n");
}
// Power the radio down
PORTA &= ~_BV(PINA1);
// Plus the CE and CSN pins
PORTA &= ~_BV(PINA7);
PORTB &= ~_BV(PINB2);
// And the onewire bus
PORTA &= ~_BV(PINA2);
} else {
myPutStr("Error measuring sensors\n");
}
//tmp = getMillis();
//radioWrite(&tmp , sizeof(unsigned long) );
// Sleep hard until WDT fires
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_mode();
}
}
void stateMachine(void)
{
/******************************************************************************
* INIT State
* Executes at boot up or when the processor is reset.
*
******************************************************************************/
if (state == STATE_INIT)
{
initPeripherals();
initInterrupts();
unsigned int checkRead;
checkRead = M24LC64FReadWord(CHECK_ADDRESS, M24LC64F_ADDRESS_0);
__delay32(EEPROM_DELAY*10);
if (checkRead)
{
homePos = 0;
M24LC64FWriteWord(HOME_ADDRESS, homePos ,M24LC64F_ADDRESS_0);
__delay32(EEPROM_DELAY*10);
M24LC64FWriteWord(CHECK_ADDRESS, homePos ,M24LC64F_ADDRESS_0);
__delay32(EEPROM_DELAY*10);
}
homePos = M24LC64FReadWord(HOME_ADDRESS, M24LC64F_ADDRESS_0); /* Retrieve the stored delay value */
//homePos = 0;
__delay32(EEPROM_DELAY*10);
motorPos = M24LC64FReadWord(MOTOR_POS_ADDRESS, M24LC64F_ADDRESS_0); /* Retrieve the stored Motor Position value */
//motorPos = 0;
__delay32(EEPROM_DELAY*10);
initPWM();
initADC();
initTMR();
indexMotor(homePos, MAX_STEPS); //MAX_STEPS is 250, moveMotor() steps 4 motor steps at a time.
}
/* End of INIT State*/
/******************************************************************************
* WARM_UP State
* As long as the warm up complete signal is not given the AFC will remain in
* this state.
******************************************************************************/
/*if (state == STATE_WARM_UP)
{
triggerINT = disableINT0();
//updateAnalogOut(homePos);
bufferFull = 0;
}*/
/******************************************************************************
* MAN State
* Executes if the user selected MAN using the proper hardware control signals
* This state enables the user to manually change configuration parameters and
* the position of the motor.
******************************************************************************/
if (state == STATE_MAN)
{
if (triggerINT || IFS0bits.INT0IF) /* Disabling the external interrupt INT0, only needed in AFC state */
{
triggerINT = disableINT0();
}
if (!MAN_DELAY_CTRL == 1) /* Check if we are setting Motor Position (= 1) or Delay (= 0) */
{
motorOrDelay = 0;
homePos = motorPos;
updateAnalogOut(homePos);
M24LC64FWriteWord(HOME_ADDRESS, homePos ,M24LC64F_ADDRESS_0);
}
else
{
motorOrDelay = 1;
updateAnalogOut(motorPos);
}
if (!MAN_DELAY_UP == 1)
{
__delay32(EEPROM_DELAY*10); /* Debouncing (50ms Delay) can be made faster for practical application */
if (motorOrDelay == 1)
{
unsigned int countTemp = 0;
count =0;
//do{
while(!MAN_DELAY_UP == 1)
{
//__delay32(EEPROM_DELAY*4);
setDir = FORWARD;
motorPos++;
moveMotor(setDir, TIMER_PERIOD2);
while(count==countTemp);
countTemp++;
updateAnalogOut(motorPos);
}
//M24LC64FWriteWord(MOTOR_POS_ADDRESS, motorPos, M24LC64F_ADDRESS_0);
//}while (count <500);
setDir = STOP;
moveMotor(setDir, TIMER_PERIOD2);
}
else
{
if (homePos >= MAX_STEPS)
homePos = MAX_STEPS;
else
homePos ++;
updateAnalogOut(homePos);
M24LC64FWriteWord(HOME_ADDRESS, homePos ,M24LC64F_ADDRESS_0);
}
}
if (!MAN_DELAY_DOWN == 1)
{
__delay32(EEPROM_DELAY*10); /* Debouncing (50ms Delay) can be made faster for practical application */
if (motorOrDelay == 1)
{
unsigned int countTemp = 0;
count =0;
//do{
while(!MAN_DELAY_DOWN == 1)
{
//__delay32(EEPROM_DELAY*4);
setDir = REVERSE;
motorPos--;
moveMotor(setDir, TIMER_PERIOD2);
while(count==countTemp);
countTemp++;
updateAnalogOut(motorPos);
}
//M24LC64FWriteWord(MOTOR_POS_ADDRESS, motorPos, M24LC64F_ADDRESS_0);
//}while (count <500);
setDir = STOP;
moveMotor(setDir, TIMER_PERIOD2);
}
else
{
if (homePos <= MIN_DELAY)
homePos = 0;
else
homePos --;
updateAnalogOut(homePos);
M24LC64FWriteWord(HOME_ADDRESS, homePos ,M24LC64F_ADDRESS_0);
}
}
}
/* End of MAN State*/
/******************************************************************************
* AFC State
* Executes if the user selected AFC using the proper hardware control signals
* This state locks all manual control and the AFC controls the motor position
******************************************************************************/
if (state == STATE_AFC)
{
if (!MAN_DELAY_UP == 1)
{
indexMotor(motorPos, MAX_STEPS);
}
if (!MAN_DELAY_DOWN == 1)
{
indexMotor(homePos, MAX_STEPS);
}
heatPerPulse = 0;
if (sampleTrigger)
{
sampleTrigger = 0;
prevReflectedPower = 0;
/* The ADC is triggered by a special comparison event of the PWM module */
ADCPC2bits.SWTRG5 = 1; /*Trigger ADC to convert AN11 (Heat Per Pulse input from PLC) */
while(!ADSTATbits.P5RDY);
heatPerPulse = ADCBUF11;
ADCPC0bits.SWTRG0 = 1; /*Trigger ADC to convert AN0 (Reflected port) */
while(!ADSTATbits.P0RDY);
prevReflectedPower = reflectedPower;
reflectedPower = ADCBUF0;
// delta = ADCBUF1;
ADSTATbits.P0RDY = 0; /* Clear the ADSTAT bits */
//ADSTATbits.P1RDY = 0;
ADSTATbits.P5RDY = 0;
/*__asm__ volatile ("clr B");
__asm__ volatile ("lac %0,B":"+r"(heatPerPulse));
__asm__ volatile ("sftac B,#16");
__asm__ volatile ("add A");*/
heatAccumulator += heatPerPulse;
/*No buffer*/
error = (int)(reflectedPower - prevReflectedPower);
/* Filtering using a FIFO buffer*/
/*errorArray[strPTR] = (int)(reflectedPower - prevReflectedPower);
strPTR++;
if (strPTR >= endPTR)
{
bufferFull = 1;
strPTR = 0;
}
if (bufferFull == 1)
{
int i;
for (i = 0; i < endPTR; i++)
{
error += errorArray[i];
}
error = error >> 5; //BUFFER_SIZE = 32 -> 2^5 = 32
}*/
/* else
{
int j;
for (j = 0; j < strPTR; j++)
{
error += errorArray[j];
}
error = error/strPTR;
}*/
triggerINT = enableINT0();
//calcError(); /* Calculate Error based on A/D results for reflected power*/
//moveMotor(setDir, motorStep);
//while (T2CONbits.TON);
}
if (thermalCounter == 50000) //Using the PWM special event interrupt to increment every TMR1 period match (~20us) 5000*20uS ~= 100mS
{
/*Reduce the accumulator by the cool rate coef.*/
heatAccumulator -= (heatAccumulator>>COOL_SHIFTS)*COOL_RATE;
}
/* Outer loop, calculates Thermal Drift effects and moves motor proactivley (Feedforward)*/
target = homePos + calcThermalError() + error;
moveMotorThermal();
}
LeanSensorController::LeanSensorController(){
sensorState = LOW;
initInterrupts();
}
int main()
{
// PORTB output for LCD
DDRB = 0xff;
PORTB = 0xff;
#ifdef BOARD2
// PORTC PC0-4 output, PC5 input
DDRC = 0x1f;
PORTC = 0x00;
sbi(PORTC, MUTE);
#endif
#ifdef BOARD1
// PORTC PC0,2-5 output, PC1 input
DDRC = 0x3d;
PORTC = 0x00;
sbi(PORTC, MUTE);
#endif
// PORTD is input with pullup
DDRD = 0x00;
PORTD = 0xff;
lcdInit();
adcInit();
readGlobalSettings();
toneCount = 5*F_CPU/tone;
initInterrupts();
initPLL();
sprintf(str, "PE1JPD 23cm v%s", version);
lcdCursor(0,0);
lcdStr(str);
_delay_ms(500);
for (;;) {
switch(mode) {
case VFO:
mode = Vfo();
writeGlobalSettings();
break;
case MEMORY:
mode = Memory();
writeGlobalSettings();
break;
case SPECTRUM:
mode = Spectrum();
break;
case MENU:
mode = Menu(mode);
break;
case MEMORY_MENU:
mode = MemoryMenu(mode);
break;
default:
mode = VFO;
break;
}
}
}
