/*! \brief Starts the passed program
*
* \param programIndex Index of the program to start.
*/
void start(uint8_t programIndex)
{
// initialize and start the passed 'program'
switch (programIndex)
{
case 0:
lcd_clear();
helloWorld();
break;
case 1:
activateLedMask = 0xFFFF; // use all LEDs
initLedBar();
initClock();
displayClock();
break;
case 2:
activateLedMask = 0xFFFE; // don't use led 0
initLedBar();
initAdc();
displayAdc();
break;
default:
break;
}
// do not resume to the menu until all buttons are released
os_waitForNoInput();
}
void setup() {
initLedBut();
initClock();
Serial.begin(115200);
Serial.println("Clock v1.0");
}
void myClock() {
int loop=1;
int h,m,s;
int color=1, size=1;
char symbol='X';
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
WORD saved_attributes;
GetConsoleScreenBufferInfo(hConsole, &consoleInfo);
saved_attributes = consoleInfo.wAttributes;
while(loop) {
if(GetAsyncKeyState(VK_ESCAPE)) {
break;
}
if(GetAsyncKeyState('C')) {
writeConfig(color, size, symbol, hConsole, saved_attributes);
GetAsyncKeyState(VK_SPACE); //Clear
GetAsyncKeyState('C');//Clear
}
readConfig(&color, &size, &symbol);
initClock(&h,&m,&s);
char f[17]= {};
initText(f,h,m,s,symbol);
system("cls");
digitalClock(h,m,s);
printClock(f,color,size,hConsole,saved_attributes);
sleep(1);
}
}
int main(void)
{
// initialize the GPIO pins we need
initClock();
init_GPIO();
init_ADC();
init_DAC();
init_GYACC();
usb::init();
Herkulex hercules;
GPIOE->ODR |= 0xC000;
Tools::Delay(Tools::DELAY_AROUND_1S / 2);
GPIOE->ODR &= ~0xC000;
enable_ADC_watchdog(2760, 3870); // ~6.9V -- ~9.5V (V33 = 3.41V)
hercules.setTorque(DEFAULT_ID, TORQUE_ON);
unsigned debounce = 10000, oldb=0;
unsigned g = GYACC_txrx(USE_GYRO, 0x8F00);
unsigned a = GYACC_txrx(USE_ACC, 0xA000);
for(;;)
{
char p[4];
uint32_t r = usb::read(p);
for (int i=0; i < r; ++i) p[i] += 2;
usb::write(p, r);
if (r) GPIOE->ODR += 0x4000;
if (!debounce--)
{
const unsigned b = ~GPIOC->IDR;
const unsigned p = (b ^ oldb) & b;
if (p & 2)
{
GPIOE->ODR ^= 0x8000;
hercules.positionControl(DEFAULT_ID, 512 + 300, 40, 0);
}
else if (p & 4)
{
GPIOE->ODR ^= 0x4000;
hercules.positionControl(DEFAULT_ID, 512, 40, 0);
}
else if (p & 8)
{
GPIOE->ODR -= 0x4000;
hercules.positionControl(DEFAULT_ID, 512 - 300, 40, 0);
}
oldb = b;
debounce = 10000;
}
}
}
void initSystem(void)
{
initClock();
setMcuFlashDataCacheEn(true);
setMcuFlashInstCacheEn(true);
initSdram();
initLtdc();
}
void initAll(void)
{
HAL_Init();
initClock();
initGPIO();
initTimers();
}
void init()
{
cli();
initPins();
initClock();
initBuffer();
initSerial();
recvMode = RM_DATA;
set_sleep_mode( SLEEP_MODE_IDLE );
sei();
}
void init()
{
Chip_SYSCTL_SetBODLevels(SYSCTL_BODRSTLVL_2_06V, SYSCTL_BODINTVAL_RESERVED1);
Chip_SYSCTL_EnableBODReset();
initWatchdog();
initClock();
initGpio();
resetWatchdog();
}
/*
* main.c
*/
int main(void) {
dht11Data_t bla;
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
initClock();
while (1) {
getData(&bla);
}
return 0;
}
int main(void)
{
unsigned int i;
int sum = 0;
int current = 0;
int hgt_percent = 0;
int degrees = 0;
STATE = IDLE;
initClock();
initADC();
initYaw();
initMotorPin();
initDisplay();
intButton();
initConsole();
initPWMchan();
initCircBuf (&g_inBuffer, BUF_SIZE);
// Enable interrupts to the processor.
IntMasterEnable();
while (1)
{
//double dt = SysCtlClockGet() / SYSTICK_RATE_HZ;
degrees = yawToDeg();
// Background task: calculate the (approximate) mean of the values in the
// circular buffer and display it.
sum = 0;
for (i = 0; i < BUF_SIZE; i++) {
current = readCircBuf (&g_inBuffer);
sum = sum + current;
}
int newHght = ADC_TO_MILLIS(sum/BUF_SIZE);
if(initialRead != 0)
{
hgt_percent = calcHeight(initialRead, newHght);
}
if (STATE == FLYING || STATE == LANDING){
PIDControl(hgt_percent, SysCtlClockGet() / SYSTICK_RATE_HZ);
PWMPulseWidthSet (PWM_BASE, PWM_OUT_1, period * main_duty / 100);
PWMPulseWidthSet (PWM_BASE, PWM_OUT_4, period * tail_duty / 100);
}
displayInfo((int)initialRead, hgt_percent, degrees);
}
}
/** \brief the main function of the project
* check current state and switch apps respectively
* \param
* \param
* \return
*
*/
int main(void)
{
/* Chip errata */
CHIP_Init();
/* If first word of user data page is non-zero, enable eA Profiler trace */
BSP_TraceProfilerSetup();
////////////////////////////////////////////////////////////////////////
setupSWO();
/* Initialize LED driver */
BSP_LedsInit();
initButtons();
initClock();
initActivity();
initVariables();
SegmentLCD_Init(false); /* Enable LCD without voltage boost */
state = main_screen;
/* Infinite blink loop */
while (1)
{
//NOTE maybe button A(change state) must be checked here
if(screen_notification == true) // don't update screen until user reaction
{
EMU_EnterEM2(true);
button = NO_BUTTON;
}
else
{
switch (state)
{
case main_screen:
mainScreenApp();
break;
case pomodoro_screen:
pomodoroApp();
break;
case activity_screen:
activityApp();
break;
case time_setup_screen:
setupTimeApp();
break;
case alarm_setup_screen:
setupAlarmApp();
break;
}
}
}
}
int main (void) {
initClock(); // clock.h
initSerial(); // serial.h
initTimer(); // timer.h
initADC(); // adc.h
initInterrupt(); // interrupt.h
initJtagShift(); // jtagshift.h
initTdbShell(); // tdbshell.h
tdbShellStart();
return 0;
}
void timerTimer( void* arg )
{
// printf( "Timer fired\n" );
playSound( 1 );
timerId = -1;
reminders = REMINDER_COUNT;
reminderTimerId = syncTimerSetTimer( reminderTime[reminders-1], timerReminder, NULL, 1 );
if( currentState == stateClock )
{
initClock( );
drawTheButtons( );
}
}
void main(void) {
unsigned char tens;
initClock();
initPin();
initTimer0();
initInterruptButtons();
while(1) {
ADCON0bits.GO = 1;
while(!ADCON0bits.DONE);
tens = ADRESH;
if (tens < 254*10/3.2/5) {
PORTBbits.RB5=1;
}
else {
PORTBbits.RB5=0;
}
}
}
int main(void)
{
//
// Set the system clock to run at 80MHz (max freq) from the PLL.
//
SysCtlClockSet(
SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN
| SYSCTL_XTAL_16MHZ);
//
// Configure SysTick for a 100Hz interrupt.
//
SysTickPeriodSet(SysCtlClockGet() / TICKS_PER_SECOND);
SysTickEnable();
/// Init RTC
rtc_init();
// Init LCD
ssd1289_init();
//
// Initialize the display context
//
GrContextInit(&sContext, pDisplay);
initClock(pDisplay);
// Init touch
xpt2046_init();
xpt2046_setTouchScreenCallback(WidgetPointerMessage);
xpt2046_enableTouchIRQ();
SysTickIntEnable();
startMainMenuApplication();
while (true)
{
//
// Process any messages in the widget message queue.
//
WidgetMessageQueueProcess();
}
}
Boolean doInit(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
DBG("manufacturerIdentity: %s\n", MANUFACTURER_ID);
/* initialize networking */
netShutdown(&ptpClock->netPath);
if(!netInit(&ptpClock->netPath, rtOpts, ptpClock))
{
ERROR("failed to initialize network\n");
toState(PTP_FAULTY, rtOpts, ptpClock);
return FALSE;
}
/* initialize other stuff */
initData(rtOpts, ptpClock);
initTimer();
initClock(rtOpts, ptpClock);
m1(ptpClock);
msgPackHeader(ptpClock->msgObuf, ptpClock);
DBG("sync message interval: %d\n", PTP_SYNC_INTERVAL_TIMEOUT(ptpClock->sync_interval));
DBG("clock identifier: %s\n", ptpClock->clock_identifier);
DBG("256*log2(clock variance): %d\n", ptpClock->clock_variance);
DBG("clock stratum: %d\n", ptpClock->clock_stratum);
DBG("clock preferred?: %s\n", ptpClock->preferred?"yes":"no");
DBG("bound interface name: %s\n", rtOpts->ifaceName);
DBG("communication technology: %d\n", ptpClock->port_communication_technology);
DBG("uuid: %02x:%02x:%02x:%02x:%02x:%02x\n",
ptpClock->port_uuid_field[0], ptpClock->port_uuid_field[1], ptpClock->port_uuid_field[2],
ptpClock->port_uuid_field[3], ptpClock->port_uuid_field[4], ptpClock->port_uuid_field[5]);
DBG("PTP subdomain name: %s\n", ptpClock->subdomain_name);
DBG("subdomain address: %x.%x.%x.%x\n",
ptpClock->subdomain_address[0], ptpClock->subdomain_address[1],
ptpClock->subdomain_address[2], ptpClock->subdomain_address[3]);
DBG("event port address: %x %x\n",
ptpClock->event_port_address[0], ptpClock->event_port_address[1]);
DBG("general port address: %x %x\n",
ptpClock->general_port_address[0], ptpClock->general_port_address[1]);
toState(PTP_LISTENING, rtOpts, ptpClock);
return TRUE;
}
void actionStartTimer( void* arg )
{
sinkTheButton( arg );
if( timerId == -1 )
{
ackTimerEnd( );
timerId = syncTimerSetTimer( timerDuration, timerTimer, NULL, 1 );
printf( "Timer started for %d sec. Id:%d\n", timerDuration / 1000, timerId );
}
else
{
syncTimerKillTimer( timerId );
timerId = -1;
}
initClock( );
//printf( "Drawing from actionStartTimer : %s\n", durationButton->txt );
drawTheButtons( );
}
int msxinit()
{
int i;
setup_io();
MSX_SET_OUTPUT(MCS_PIN);
MSX_SET_OUTPUT(MA0_PIN);
MSX_SET_OUTPUT(MODE_PIN);
MSX_SET_OUTPUT(RW_PIN);
MSX_SET_OUTPUT(MIO_PIN);
MSX_SET_OUTPUT(SLTSL_PIN);
MSX_SET_OUTPUT(RESET_PIN);
initClock(0, 0, 10, 492, 0);
MSX_SET_CLOCK(MCLK_PIN);
GPIO_CLR = MSX_RESET;
usleep(1000);
GPIO_SET = MSX_RESET;
for (i = 0; i < 16; i++)
{
INP_GPIO(MD00_PIN+i);
OUT_GPIO(MD00_PIN+i);
}
}
static Boolean doInit(PtpClock *ptpClock)
{
DBG("manufacturerIdentity: %s\n", MANUFACTURER_ID);
/* initialize networking */
netShutdown(&ptpClock->netPath);
if (!netInit(&ptpClock->netPath, ptpClock))
{
ERROR("doInit: failed to initialize network\n");
return FALSE;
}
else
{
/* initialize other stuff */
initData(ptpClock);
initTimer();
initClock(ptpClock);
m1(ptpClock);
msgPackHeader(ptpClock, ptpClock->msgObuf);
return TRUE;
}
}
Boolean
doInit(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
DBG("manufacturerIdentity: %s\n", MANUFACTURER_ID);
/* initialize networking */
netShutdown(&ptpClock->netPath);
if (!netInit(&ptpClock->netPath, rtOpts, ptpClock)) {
ERROR("failed to initialize network\n");
toState(PTP_FAULTY, rtOpts, ptpClock);
return FALSE;
}
/* initialize other stuff */
initData(rtOpts, ptpClock);
initTimer();
initClock(rtOpts, ptpClock);
m1(rtOpts, ptpClock );
msgPackHeader(ptpClock->msgObuf, ptpClock);
toState(PTP_LISTENING, rtOpts, ptpClock);
return TRUE;
}
void initSoftClock(Clock* clockParam) {
initClock(clockParam, _writeSoftClock, _readSoftClock, NULL);
ClockData* clockData = &(clockParam->clockData);
addTimer(TIMER_SOFT_CLOCK_CODE, SOFT_CLOCK_UPDATE_FREQUENCY, &incrementOneSecondSoftClock, "SOFT CLOCK", (int*) clockData);
}
/*!
Constructor
\param parent Parent widget
*/
QwtAnalogClock::QwtAnalogClock( QWidget *parent ):
QwtDial( parent )
{
initClock();
}
//
// ‘”Ќ ÷»я: InitInstance(HINSTANCE, int)
//
// Ќј«Ќј„≈Ќ»≈: сохран¤ет обработку экземпл¤ра и создает главное окно.
//
// ќћћ≈Ќ“ј–»»:
//
// ¬ данной функции дескриптор экземпл¤ра сохран¤етс¤ в глобальной переменной, а также
// создаетс¤ и выводитс¤ на экран главное окно программы.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
hInst = hInstance; // —охранить дескриптор экземпл¤ра в глобальной переменной
HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);
if (!hWnd)
{
return FALSE;
}
HWND textMove = CreateWindowW(TEXT("static"), TEXT(" Move: X: Y:"),
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_CENTERIMAGE,
15, 15, 240, 36,
hWnd, NULL,
hInstance, NULL);
HWND hwndEditMoveX = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 95, 23, 30, 20, hWnd, (HMENU)ID_EDIT_MOVEX, NULL, NULL);
HWND hwndEditMoveY = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 155, 23, 30, 20, hWnd, (HMENU)ID_EDIT_MOVEY, NULL, NULL);
HWND hwndButtonMove = CreateWindowW(TEXT("BUTTON"), TEXT("Apply"),
WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, 195, 23, 50, 20, hWnd, (HMENU)ID_BUTTON_MOVE, hInstance, NULL);
HWND textScale = CreateWindowW(TEXT("static"), TEXT(" Scale: Proportions:"),
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_CENTERIMAGE,
15, 66, 240, 30,
hWnd, NULL,
hInstance, NULL);
HWND textScaleX = CreateWindowW(TEXT("static"), TEXT(" X:"),
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_CENTERIMAGE,
15, 96, 240, 30,
hWnd, NULL,
hInstance, NULL);
HWND textScaleY = CreateWindowW(TEXT("static"), TEXT(" Y:"),
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_CENTERIMAGE,
15, 126, 240, 30,
hWnd, NULL,
hInstance, NULL);
HWND hwndEditScaleProportions = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 155, 74, 30, 20, hWnd, (HMENU)ID_EDIT_SCALEPROPORTIONS, NULL, NULL);
HWND hwndEditScaleX = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 155, 104, 30, 20, hWnd, (HMENU)ID_EDIT_SCALEX, NULL, NULL);
HWND hwndEditScaleY = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 155, 134, 30, 20, hWnd, (HMENU)ID_EDIT_SCALEY, NULL, NULL);
HWND hwndButtonScale = CreateWindowW(TEXT("BUTTON"), TEXT("Apply"),
WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, 195, 74, 50, 20, hWnd, (HMENU)ID_BUTTON_SCALE, hInstance, NULL);
HWND textRotate = CreateWindowW(TEXT("static"), TEXT(" Rotate: Angle:"),
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_CENTERIMAGE,
15, 117 + 55, 240, 30,
hWnd, NULL,
hInstance, NULL);
HWND textRotateX = CreateWindowW(TEXT("static"), TEXT(" X:"),
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_CENTERIMAGE,
15, 147 + 55, 240, 30,
hWnd, NULL,
hInstance, NULL);
HWND textRotateY = CreateWindowW(TEXT("static"), TEXT(" Y:"),
WS_CHILD | WS_VISIBLE | WS_TABSTOP | SS_CENTERIMAGE,
15, 177 + 55, 240, 30,
hWnd, NULL,
hInstance, NULL);
HWND hwndEditRotateAngle = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 155, 125 + 55, 30, 20, hWnd, (HMENU)ID_EDIT_ROTATEANGLE, NULL, NULL);
HWND hwndEditRotateX = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 155, 155 + 55, 30, 20, hWnd, (HMENU)ID_EDIT_ROTATEX, NULL, NULL);
HWND hwndEditRotateY = CreateWindowExW(WS_EX_WINDOWEDGE, TEXT("Edit"), TEXT("0"),
WS_CHILD | WS_VISIBLE | WS_BORDER, 155, 185 + 55, 30, 20, hWnd, (HMENU)ID_EDIT_ROTATEY, NULL, NULL);
HWND hwndButtonRotate = CreateWindowW(TEXT("BUTTON"), TEXT("Apply"),
WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, 195, 125 + 55, 50, 20, hWnd, (HMENU)ID_BUTTON_ROTATE, hInstance, NULL);
HWND hwndButtonReset = CreateWindowW(TEXT("BUTTON"), TEXT("Reset"),
WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, 15, 230 + 55, 50, 20, hWnd, (HMENU)ID_BUTTON_RESET, hInstance, NULL);
initClock();
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
void
servo_perform_clock_step(RunTimeOpts * rtOpts, PtpClock * ptpClock)
{
if(rtOpts->noAdjust){
WARNING("Could not step clock - clock adjustment disabled\n");
return;
}
TimeInternal oldTime, newTime;
/*No need to reset the frequency offset: if we're far off, it will quickly get back to a high value */
getTime(&oldTime);
subTime(&newTime, &oldTime, &ptpClock->offsetFromMaster);
setTime(&newTime);
#ifdef HAVE_LINUX_RTC_H
if(rtOpts->setRtc) {
setRtc(&newTime);
}
#endif /* HAVE_LINUX_RTC_H */
initClock(rtOpts, ptpClock);
#ifdef HAVE_SYS_TIMEX_H
if(ptpClock->clockQuality.clockClass > 127)
restoreDrift(ptpClock, rtOpts, TRUE);
#endif /* HAVE_SYS_TIMEX_H */
ptpClock->servo.runningMaxOutput = FALSE;
toState(PTP_FAULTY, rtOpts, ptpClock); /* make a full protocol reset */
/* Major time change - need to inform utmp / wtmp */
if(oldTime.seconds != newTime.seconds) {
/* Add the old time entry to utmp/wtmp */
/* About as long as the ntpd implementation, but not any less ugly */
#ifdef HAVE_UTMPX_H
struct utmpx utx;
memset(&utx, 0, sizeof(utx));
strncpy(utx.ut_user, "date", sizeof(utx.ut_user));
#ifndef OTIME_MSG
strncpy(utx.ut_line, "|", sizeof(utx.ut_line));
#else
strncpy(utx.ut_line, OTIME_MSG, sizeof(utx.ut_line));
#endif /* OTIME_MSG */
#ifdef OLD_TIME
utx.ut_tv.tv_sec = oldTime.seconds;
utx.ut_tv.tv_usec = oldTime.nanoseconds / 1000;
utx.ut_type = OLD_TIME;
#else /* no ut_type */
utx.ut_time = oldTime.seconds;
#endif /* OLD_TIME */
/* ======== BEGIN OLD TIME EVENT - UTMPX / WTMPX =========== */
#ifdef HAVE_UTMPXNAME
utmpxname("/var/log/utmp");
#endif /* HAVE_UTMPXNAME */
setutxent();
pututxline(&utx);
endutxent();
#ifdef HAVE_UPDWTMPX
updwtmpx("/var/log/wtmp", &utx);
#endif /* HAVE_IPDWTMPX */
/* ======== END OLD TIME EVENT - UTMPX / WTMPX =========== */
#else /* NO UTMPX_H */
#ifdef HAVE_UTMP_H
struct utmp ut;
memset(&ut, 0, sizeof(ut));
strncpy(ut.ut_name, "date", sizeof(ut.ut_name));
#ifndef OTIME_MSG
strncpy(ut.ut_line, "|", sizeof(ut.ut_line));
#else
strncpy(ut.ut_line, OTIME_MSG, sizeof(ut.ut_line));
#endif /* OTIME_MSG */
#ifdef OLD_TIME
ut.ut_tv.tv_sec = oldTime.seconds;
ut.ut_tv.tv_usec = oldTime.nanoseconds / 1000;
ut.ut_type = OLD_TIME;
#else /* no ut_type */
ut.ut_time = oldTime.seconds;
#endif /* OLD_TIME */
/* ======== BEGIN OLD TIME EVENT - UTMP / WTMP =========== */
#ifdef HAVE_UTMPNAME
utmpname(UTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
#ifdef HAVE_UTMPNAME
utmpname(WTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
/* ======== END OLD TIME EVENT - UTMP / WTMP =========== */
#endif /* HAVE_UTMP_H */
#endif /* HAVE_UTMPX_H */
/* Add the new time entry to utmp/wtmp */
#ifdef HAVE_UTMPX_H
memset(&utx, 0, sizeof(utx));
strncpy(utx.ut_user, "date", sizeof(utx.ut_user));
#ifndef NTIME_MSG
strncpy(utx.ut_line, "}", sizeof(utx.ut_line));
#else
strncpy(utx.ut_line, NTIME_MSG, sizeof(utx.ut_line));
#endif /* NTIME_MSG */
#ifdef NEW_TIME
utx.ut_tv.tv_sec = newTime.seconds;
utx.ut_tv.tv_usec = newTime.nanoseconds / 1000;
utx.ut_type = NEW_TIME;
#else /* no ut_type */
utx.ut_time = newTime.seconds;
#endif /* NEW_TIME */
/* ======== BEGIN NEW TIME EVENT - UTMPX / WTMPX =========== */
#ifdef HAVE_UTMPXNAME
utmpxname("/var/log/utmp");
#endif /* HAVE_UTMPXNAME */
setutxent();
pututxline(&utx);
endutxent();
#ifdef HAVE_UPDWTMPX
updwtmpx("/var/log/wtmp", &utx);
#endif /* HAVE_UPDWTMPX */
/* ======== END NEW TIME EVENT - UTMPX / WTMPX =========== */
#else /* NO UTMPX_H */
#ifdef HAVE_UTMP_H
memset(&ut, 0, sizeof(ut));
strncpy(ut.ut_name, "date", sizeof(ut.ut_name));
#ifndef NTIME_MSG
strncpy(ut.ut_line, "}", sizeof(ut.ut_line));
#else
strncpy(ut.ut_line, NTIME_MSG, sizeof(ut.ut_line));
#endif /* NTIME_MSG */
#ifdef NEW_TIME
ut.ut_tv.tv_sec = newTime.seconds;
ut.ut_tv.tv_usec = newTime.nanoseconds / 1000;
ut.ut_type = NEW_TIME;
#else /* no ut_type */
ut.ut_time = newTime.seconds;
#endif /* NEW_TIME */
/* ======== BEGIN NEW TIME EVENT - UTMP / WTMP =========== */
#ifdef HAVE_UTMPNAME
utmpname(UTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
#ifdef HAVE_UTMPNAME
utmpname(WTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
/* ======== END NEW TIME EVENT - UTMP / WTMP =========== */
#endif /* HAVE_UTMP_H */
#endif /* HAVE_UTMPX_H */
}
}
// Main function
void main(void) {
reset_peripheral(); initClock(); initTimer(); initDisplay(); initPin();
initGPIO(); initADC(); initConsole(); int i = 0;
//init_password();
send_data();
initCircBuf (&speed_buffer, BUF_SIZE); init_set_speed_data(&speed_set_data);
int screen = 0; int screen_prev = 0; float speed = 0; float buffed_speed = 0;
int fake_speed = 0; float acc = 0; float max_acc = 0; //float fuel_eco = 0;
float distance = 0;
bool fix = 0; uint8_t satillite = 0; float quality = 0; clock time;
int aim_pos = 0; unsigned long adc = 0; //int error_stepper = 0;
IntMasterEnable();
while(1){
//reading data
read_data = split_data(UART_char_data_old, read_data); // decode data
speed = read_speed(); //read data into variables
adc = run_adc()/7;
//calculations
aim_pos = speed_feedback(buffed_speed, encoder_1/40, speed_set_data.speed);
if (speed_set_data.enable == 1){
step_motor_control(encoder_1/40, aim_pos);
}
//sending fake data
fake_speed = (int)adc;//= random_at_most(100/1.852);
send_info(fake_speed);//knots
//storing data
store_speed(speed);
buffed_speed = analysis_speed();
acc = read_acceleration(buffed_speed);
max_acc = max_acc_func(acc, max_acc);
time = read_time();
satillite = read_satillite();
fix = read_fix();
quality = read_quality();
debounce_button(); // debounce buttons
screen = read_button_screen(screen, fix);
distance = read_distance();
select_read(); //need a mosfet for turning power off
// select adds a an on and off switch yo
if (screen == 1){
if(screen_prev != 1 && screen == 1){
speed_set_data.speed = buffed_speed;
}
speed_set_data.speed = set_speed(speed_set_data.speed); // set the speed to cruise at
}
if (screen == 2){ //0 to 100
acceleration_test(speed);
}
// refresh chainging
if (fix == 1 && speed_set_data.old == speed_set_data.speed && refresh_rate < 4){
UARTSend((unsigned char *)PMTK_SET_NMEA_UPDATE_5HZ, 18, 0);
refresh_rate += 1;
}
if (i >= 50){
display(screen, buffed_speed, acc, max_acc, speed_set_data.speed, satillite,
encoder_1/40, time, distance, quality, UART_char_data_old, aim_pos, adc, acc_times);
i = 0;
}
screen_prev = screen;
i++;
}
}
/* perform actions required when leaving 'port_state' and entering 'state' */
void toState(PtpClock *ptpClock, UInteger8 state)
{
ptpClock->messageActivity = TRUE;
/* leaving state tasks */
switch (ptpClock->portDS.portState)
{
case PTP_MASTER:
initClock(ptpClock);
timerStop(SYNC_INTERVAL_TIMER, ptpClock->itimer);
timerStop(ANNOUNCE_INTERVAL_TIMER, ptpClock->itimer);
timerStop(PDELAYREQ_INTERVAL_TIMER, ptpClock->itimer);
break;
case PTP_UNCALIBRATED:
case PTP_SLAVE:
if (state == PTP_UNCALIBRATED || state == PTP_SLAVE)
{
break;
}
timerStop(ANNOUNCE_RECEIPT_TIMER, ptpClock->itimer);
switch (ptpClock->portDS.delayMechanism)
{
case E2E:
timerStop(DELAYREQ_INTERVAL_TIMER, ptpClock->itimer);
break;
case P2P:
timerStop(PDELAYREQ_INTERVAL_TIMER, ptpClock->itimer);
break;
default:
/* none */
break;
}
initClock(ptpClock);
break;
case PTP_PASSIVE:
initClock(ptpClock);
timerStop(PDELAYREQ_INTERVAL_TIMER, ptpClock->itimer);
timerStop(ANNOUNCE_RECEIPT_TIMER, ptpClock->itimer);
break;
case PTP_LISTENING:
initClock(ptpClock);
timerStop(ANNOUNCE_RECEIPT_TIMER, ptpClock->itimer);
break;
case PTP_PRE_MASTER:
initClock(ptpClock);
timerStop(QUALIFICATION_TIMEOUT, ptpClock->itimer);
break;
default:
break;
}
/* entering state tasks */
switch (state)
{
case PTP_INITIALIZING:
DBG("state PTP_INITIALIZING\n");
ptpClock->portDS.portState = PTP_INITIALIZING;
ptpClock->recommendedState = PTP_INITIALIZING;
break;
case PTP_FAULTY:
DBG("state PTP_FAULTY\n");
ptpClock->portDS.portState = PTP_FAULTY;
break;
case PTP_DISABLED:
DBG("state PTP_DISABLED\n");
ptpClock->portDS.portState = PTP_DISABLED;
break;
case PTP_LISTENING:
DBG("state PTP_LISTENING\n");
timerStart(ANNOUNCE_RECEIPT_TIMER, (ptpClock->portDS.announceReceiptTimeout)*(pow2ms(ptpClock->portDS.logAnnounceInterval)), ptpClock->itimer);
ptpClock->portDS.portState = PTP_LISTENING;
ptpClock->recommendedState = PTP_LISTENING;
break;
case PTP_PRE_MASTER:
DBG("state PTP_PRE_MASTER\n");
/* If you implement not ordinary clock, you can manage this code */
/* timerStart(QUALIFICATION_TIMEOUT, pow2ms(DEFAULT_QUALIFICATION_TIMEOUT), ptpClock->itimer);
ptpClock->portDS.portState = PTP_PRE_MASTER;
break;
*/
case PTP_MASTER:
DBG("state PTP_MASTER\n");
ptpClock->portDS.logMinDelayReqInterval = DEFAULT_DELAYREQ_INTERVAL; /* it may change during slave state */
timerStart(SYNC_INTERVAL_TIMER, pow2ms(ptpClock->portDS.logSyncInterval), ptpClock->itimer);
DBG("SYNC INTERVAL TIMER : %d \n", pow2ms(ptpClock->portDS.logSyncInterval));
timerStart(ANNOUNCE_INTERVAL_TIMER, pow2ms(ptpClock->portDS.logAnnounceInterval), ptpClock->itimer);
switch (ptpClock->portDS.delayMechanism)
{
case E2E:
/* none */
break;
case P2P:
timerStart(PDELAYREQ_INTERVAL_TIMER, getRand(pow2ms(ptpClock->portDS.logMinPdelayReqInterval) + 1), ptpClock->itimer);
break;
default:
break;
}
ptpClock->portDS.portState = PTP_MASTER;
break;
case PTP_PASSIVE:
DBG("state PTP_PASSIVE\n");
timerStart(ANNOUNCE_RECEIPT_TIMER, (ptpClock->portDS.announceReceiptTimeout)*(pow2ms(ptpClock->portDS.logAnnounceInterval)), ptpClock->itimer);
if (ptpClock->portDS.delayMechanism == P2P)
{
timerStart(PDELAYREQ_INTERVAL_TIMER, getRand(pow2ms(ptpClock->portDS.logMinPdelayReqInterval + 1)), ptpClock->itimer);
}
ptpClock->portDS.portState = PTP_PASSIVE;
break;
case PTP_UNCALIBRATED:
DBG("state PTP_UNCALIBRATED\n");
timerStart(ANNOUNCE_RECEIPT_TIMER, (ptpClock->portDS.announceReceiptTimeout)*(pow2ms(ptpClock->portDS.logAnnounceInterval)), ptpClock->itimer);
switch (ptpClock->portDS.delayMechanism)
{
case E2E:
timerStart(DELAYREQ_INTERVAL_TIMER, getRand(pow2ms(ptpClock->portDS.logMinDelayReqInterval + 1)), ptpClock->itimer);
break;
case P2P:
timerStart(PDELAYREQ_INTERVAL_TIMER, getRand(pow2ms(ptpClock->portDS.logMinPdelayReqInterval + 1)), ptpClock->itimer);
break;
default:
/* none */
break;
}
ptpClock->portDS.portState = PTP_UNCALIBRATED;
break;
case PTP_SLAVE:
DBG("state PTP_SLAVE\n");
ptpClock->portDS.portState = PTP_SLAVE;
break;
default:
DBG("toState: unrecognized %d\n", state);
break;
}
}
//This function checks to see if the clock speed needs to be changed
//if the current speed does not match the desired speed, it calls
//initClock function to update the clock speed
//For this function to work properly, button.h was included
//in clock.c and the number of ticks in the interrupt section was
//divided by speedUpdate() function
void speedChange()
{
int x = speeds;
if(x != speedUpdate())
initClock();
}
int main(int argc, char **argv){
ALLEGRO_DISPLAY *display = NULL;
ALLEGRO_EVENT_QUEUE *event_queue = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_BITMAP *seletor = NULL;
float tamanho = 25;
float espacamento = SELETOR_SIZE + 19;
float seletor_x = 1174;
float seletor_y = 40;
bool key[4] = { false, false, false, false };
bool redraw = true;
bool doexit = false;
float posicao = 0;
int mapa[770][3];
bool envio[4] = { false, false, false, false };
//Inicia o allegro
al_init();
al_init_image_addon();
al_install_keyboard();
// Inicialização do add-on para uso de fontes
al_init_font_addon();
al_init_ttf_addon();
inicializaBitmaps();
lerConf(mapa);
//Cria a lista de eventos
event_queue = al_create_event_queue();
//Cria o timer
timer = al_create_timer(1.0 / FPS);
//Cria a janela
display = al_create_display(SCREEN_W, SCREEN_H);
//Limpa a janela com a cor preta
al_clear_to_color(al_map_rgb(0, 0, 0));
//Carrega a imagem de fundo na variável
background = al_load_bitmap("img/fundo.png");
//Desenha a imagem de fundo na posição (0,0)
al_draw_bitmap(background, 0, 0, 0);
//Carrega a imagem do seletor na variável
seletor = al_load_bitmap("img/selecao.png");
//Desenha o seletor na posição (1174,40)
al_draw_bitmap(seletor, 1174, 40, 0);
desenhaMapa(mapa, envio);
//Registra os eventos
al_register_event_source(event_queue, al_get_display_event_source(display));
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_register_event_source(event_queue, al_get_keyboard_event_source());
al_flip_display();
//Inicia o timer
al_start_timer(timer);
//Inicia contagem de tempo para a pergunta aparecer
initClock();
//While do jogo
while(!doexit){
//Aguarda o evento
ALLEGRO_EVENT ev;
al_wait_for_event(event_queue, &ev);
//Se der o tempo do timer, verifica qual tecla foi pressionada e se é possível se mover para a posição de destino
if(ev.type == ALLEGRO_EVENT_TIMER){
if(key[KEY_LEFT] && (posicao == 1 || posicao == 3) && (janela_aberta == 0)) {
seletor_x -= espacamento;
if(posicao == 1)
posicao = 0;
else
posicao = 2;
}
if(key[KEY_RIGHT] && (posicao == 0 || posicao == 2) && (janela_aberta == 0)) {
seletor_x += espacamento;
if(posicao == 0)
posicao = 1;
else
posicao = 3;
}
if(key[KEY_UP] && (posicao == 2 || posicao == 3) && (janela_aberta == 0)) {
seletor_y -= espacamento;
if(posicao == 2)
posicao = 0;
else
posicao = 1;
}
if(key[KEY_DOWN] && (posicao == 0 || posicao == 1) && (janela_aberta == 0)) {
seletor_y += espacamento;
if(posicao == 0)
posicao = 2;
else
posicao = 3;
}
redraw = true;
}
//Se a janela for fechada, termina o jogo
else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
//Se o evento for um tecla pressionada, seta a variável dessa tecla para "true" (pressionada)
else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = true;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = true;
break;
case ALLEGRO_KEY_UP:
key[KEY_UP] = true;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = true;
break;
}
}
//Se o evento for um tecla solta, seta a variável dessa tecla para "false" (caso seja Esc, encerra o programa)
else if(ev.type == ALLEGRO_EVENT_KEY_UP) {
switch(ev.keyboard.keycode) {
case ALLEGRO_KEY_LEFT:
key[KEY_LEFT] = false;
break;
case ALLEGRO_KEY_RIGHT:
key[KEY_RIGHT] = false;
break;
case ALLEGRO_KEY_ESCAPE:
doexit = true;
break;
case ALLEGRO_KEY_UP:
key[KEY_UP] = false;
break;
case ALLEGRO_KEY_DOWN:
key[KEY_DOWN] = false;
break;
case ALLEGRO_KEY_ENTER:
if (janela_aberta == 0){
if(posicao == 0)
envio[VERMELHO] = true;
else if(posicao == 1)
envio[AZUL] = true;
else if(posicao == 2)
envio[VERDE] = true;
else if(posicao == 3)
envio[AMARELO] = true;
}
}
}
//Redesenha o jogo
if(redraw && al_is_event_queue_empty(event_queue)){
redraw = false;
al_draw_bitmap(background, 0, 0, 0);
desenhaMapa(mapa, envio);
movimento(mapa);
if (janela_aberta == 0){
if (checkClock()){
janela_aberta = 1;
}
}else{
al_draw_bitmap(perguntas, 0, 0, 0);
al_draw_textf(font, al_map_rgb(255, 255, 255), SCREEN_W / 2, 250, ALLEGRO_ALIGN_CENTRE, "%s", texto);
printf("check\n");
initClock();
}
al_draw_bitmap(seletor, seletor_x, seletor_y, 0);
al_flip_display();
}
}
//Destrói os objetos
al_destroy_bitmap(background);
al_destroy_bitmap(seletor);
al_destroy_timer(timer);
al_destroy_display(display);
al_destroy_event_queue(event_queue);
return 0;
}
Boolean doInit(PtpClock *ptpClock)
{
DBG("manufacturerIdentity: %s\n", MANUFACTURER_ID);
/* initialize networking */
netShutdown(ptpClock);
if(!netInit(ptpClock))
{
ERROR("failed to initialize network\n");
toState(PTP_FAULTY, ptpClock);
return FALSE;
}
/* initialize timing, may fail e.g. if timer depends on hardware */
if(!initTime(ptpClock))
{
ERROR("failed to initialize timing\n");
toState(PTP_FAULTY, ptpClock);
return FALSE;
}
switch (ptpClock->runTimeOpts.time) {
case TIME_SYSTEM:
case TIME_SYSTEM_LINUX_HW:
case TIME_SYSTEM_LINUX_SW:
/*
* send time stamp will be returned to socket when available,
* either via IP_MULTICAST_LOOP or SIOCSHWTSTAMP + error queue
*/
ptpClock->delayedTiming = FALSE;
break;
default:
/* ask for time stamp shortly after sending */
ptpClock->delayedTiming = TRUE;
break;
}
/* initialize other stuff */
initData(ptpClock);
initTimer();
initClock(ptpClock);
m1(ptpClock);
msgPackHeader(ptpClock->msgObuf, ptpClock);
DBG("sync message interval: %d\n", PTP_SYNC_INTERVAL_TIMEOUT(ptpClock->sync_interval));
DBG("clock identifier: %s\n", ptpClock->clock_identifier);
DBG("256*log2(clock variance): %d\n", ptpClock->clock_variance);
DBG("clock stratum: %d\n", ptpClock->clock_stratum);
DBG("clock preferred?: %s\n", ptpClock->preferred?"yes":"no");
DBG("bound interface name: %s\n", ptpClock->runTimeOpts.ifaceName);
DBG("communication technology: %d\n", ptpClock->port_communication_technology);
DBG("uuid: %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
ptpClock->port_uuid_field[0], ptpClock->port_uuid_field[1], ptpClock->port_uuid_field[2],
ptpClock->port_uuid_field[3], ptpClock->port_uuid_field[4], ptpClock->port_uuid_field[5]);
DBG("PTP subdomain name: %s\n", ptpClock->subdomain_name);
DBG("subdomain address: %hhx.%hhx.%hhx.%hhx\n",
ptpClock->subdomain_address[0], ptpClock->subdomain_address[1],
ptpClock->subdomain_address[2], ptpClock->subdomain_address[3]);
DBG("event port address: %hhx %hhx\n",
ptpClock->event_port_address[0], ptpClock->event_port_address[1]);
DBG("general port address: %hhx %hhx\n",
ptpClock->general_port_address[0], ptpClock->general_port_address[1]);
toState(PTP_LISTENING, ptpClock);
return TRUE;
}
/* perform actions required when leaving 'port_state' and entering 'state' */
void toState(UInteger8 state, PtpClock *ptpClock)
{
ptpClock->message_activity = TRUE;
/* leaving state tasks */
switch(ptpClock->port_state)
{
case PTP_MASTER:
timerStop(SYNC_INTERVAL_TIMER, ptpClock->itimer);
timerStart(SYNC_RECEIPT_TIMER, PTP_SYNC_RECEIPT_TIMEOUT(ptpClock->sync_interval), ptpClock->itimer);
break;
case PTP_SLAVE:
initClock(ptpClock);
break;
default:
break;
}
timeToState(state, ptpClock);
/* entering state tasks */
switch(state)
{
case PTP_INITIALIZING:
DBG("state PTP_INITIALIZING\n");
timerStop(SYNC_RECEIPT_TIMER, ptpClock->itimer);
ptpClock->port_state = PTP_INITIALIZING;
break;
case PTP_FAULTY:
DBG("state PTP_FAULTY\n");
timerStop(SYNC_RECEIPT_TIMER, ptpClock->itimer);
ptpClock->port_state = PTP_FAULTY;
break;
case PTP_DISABLED:
DBG("state change to PTP_DISABLED\n");
timerStop(SYNC_RECEIPT_TIMER, ptpClock->itimer);
ptpClock->port_state = PTP_DISABLED;
break;
case PTP_LISTENING:
DBG("state PTP_LISTENING\n");
timerStart(SYNC_RECEIPT_TIMER, PTP_SYNC_RECEIPT_TIMEOUT(ptpClock->sync_interval), ptpClock->itimer);
ptpClock->port_state = PTP_LISTENING;
break;
case PTP_MASTER:
DBG("state PTP_MASTER\n");
if(ptpClock->port_state != PTP_PRE_MASTER)
timerStart(SYNC_INTERVAL_TIMER, PTP_SYNC_INTERVAL_TIMEOUT(ptpClock->sync_interval), ptpClock->itimer);
timerStop(SYNC_RECEIPT_TIMER, ptpClock->itimer);
ptpClock->port_state = PTP_MASTER;
break;
case PTP_PASSIVE:
DBG("state PTP_PASSIVE\n");
ptpClock->port_state = PTP_PASSIVE;
break;
case PTP_UNCALIBRATED:
DBG("state PTP_UNCALIBRATED\n");
ptpClock->port_state = PTP_UNCALIBRATED;
break;
case PTP_SLAVE:
DBG("state PTP_PTP_SLAVE\n");
initClock(ptpClock);
/* R is chosen to allow a few syncs before we first get a one-way delay estimate */
/* this is to allow the offset filter to fill for an accurate initial clock reset */
ptpClock->Q = 0;
ptpClock->R = getRand(&ptpClock->random_seed)%4 + 4;
DBG("Q = %d, R = %d\n", ptpClock->Q, ptpClock->R);
ptpClock->waitingForFollow = FALSE;
ptpClock->delay_req_send_time.seconds = 0;
ptpClock->delay_req_send_time.nanoseconds = 0;
ptpClock->delay_req_receive_time.seconds = 0;
ptpClock->delay_req_receive_time.nanoseconds = 0;
timerStart(SYNC_RECEIPT_TIMER, PTP_SYNC_RECEIPT_TIMEOUT(ptpClock->sync_interval), ptpClock->itimer);
ptpClock->port_state = PTP_SLAVE;
break;
default:
DBG("to unrecognized state\n");
break;
}
if(ptpClock->runTimeOpts.displayStats)
displayStats(ptpClock);
}