/*----------------------------------------------------------------------------
* Thread 1: Send thread
*---------------------------------------------------------------------------*/
void send_thread (void const *argument) {
T_MEAS *mptr;
mptr = osPoolAlloc(mpool); /* Allocate memory for the message */
mptr->voltage = 223.72; /* Set the message content */
mptr->current = 17.54;
mptr->counter = 120786;
osMessagePut(MsgBox, (uint32_t)mptr, osWaitForever); /* Send Message */
osDelay(100);
mptr = osPoolAlloc(mpool); /* Allocate memory for the message */
mptr->voltage = 227.23; /* Prepare a 2nd message */
mptr->current = 12.41;
mptr->counter = 170823;
osMessagePut(MsgBox, (uint32_t)mptr, osWaitForever); /* Send Message */
osThreadYield(); /* Cooperative multitasking */
osDelay(100);
mptr = osPoolAlloc(mpool); /* Allocate memory for the message */
mptr->voltage = 229.44; /* Prepare a 3rd message */
mptr->current = 11.89;
mptr->counter = 237178;
osMessagePut(MsgBox, (uint32_t)mptr, osWaitForever); /* Send Message */
osDelay(100);
/* We are done here, exit this thread */
}
/*! \fn void threadIdle (void const *argument)
\brief Thread definition for the idle thread.
\param argument A pointer to the list of arguments.
*/
void threadIdle (void const *argument)
{
if (addTraceProtected("threadIdle start run") != TRACE_OK)
{
stop_cpu;
}
while (1)
{
work();
if (addTraceProtected("threadIdle yields") != TRACE_OK)
{
stop_cpu;
}
osThreadYield(); // suspend thread
// throttle mechanism in place to stop this thread from running if no other traces added but its own
// if other work scheduled, this mechanism can be removed or adapted as necessary
while (getTraceCounter() <= 3)
{
osThreadYield(); // suspend thread
}
if (addTraceProtected("threadIdle back from yield") != TRACE_OK)
{
stop_cpu;
}
}
}
char * Cyassl_fgets ( char * str, int num, FILE * f )
{
int i ;
for(i = 0 ; i< num ; i++) {
while((str[i] = getkey()) == 0) {
#if defined (HAVE_KEIL_RTX)
#if !defined(CYASSL_CMSIS_RTOS)
os_tsk_pass ();
#else
osThreadYield ();
#endif
#endif
}
if(str[i] == '\n' || str[i] == '\012' || str[i] == '\015') {
sendchar('\n') ;
str[i++] = '\n' ;
str[i] = '\0' ;
break ;
} else if(str[i] == '\010') { /* BS */
if(i) { /* erace one char */
sendchar('\010') ; sendchar(' ') ; sendchar('\010') ;
i = (i>0 ? (i-2) : -1 ) ;
continue ;
}
} else if(str[i] == '\033' || str[i] == '\004' ) { /* ESC or ^D */
str[i] = '\0' ;
return(0) ;
}
sendchar(str[i]) ;
}
return(str) ;
}
void Thread_Mutex(void const *argument) {
osStatus status;
while(1) {
; // Insert thread code here...
status = osMutexWait(mid_Thread_Mutex, NULL);
switch(status) {
case osOK:
; // Use protected code here...
osMutexRelease(mid_Thread_Mutex);
break;
case osErrorTimeoutResource:
break;
case osErrorResource:
break;
case osErrorParameter:
break;
case osErrorISR:
break;
default:
break;
}
osThreadYield(); // suspend thread
}
}
void Thread (void const *argument) {
while (1) {
; // Insert thread code here...
osThreadYield (); // suspend thread
}
}
/*----------------------------------------------------------------------------
* Thread 2: 'job2'
*---------------------------------------------------------------------------*/
void job2 (void const *argument) {
while (1) { /* endless loop */
counter2++; /* increment counter 2 */
if (counter2 == 0) { /* signal overflow of counter 2 */
osSignalSet(thread3_id, 0x0001);/* to thread 3 */
osThreadYield();
}
}
}
void Thread_1 (void const *argument) {
while (1) {
RGB(0,0,1);
osDelay(1000);
osThreadYield(); // suspend thread
}
}
/*
* \brief handle sketch
*/
void main_task( void const *arg )
{
delay(1);
setup();
for (;;)
{
loop();
if (serialEventRun) serialEventRun();
osThreadYield();
}
}
void Thread_MailQueue1(void const *argument) {
MAILQUEUE_OBJ_t *pMail = 0;
while(1) {
; // Insert thread code here...
pMail = osMailAlloc(qid_MailQueue, osWaitForever); // Allocate memory
if(pMail) {
pMail->Buf[0] = 0xff; // Set the mail content
pMail->Idx = 0;
osMailPut(qid_MailQueue, pMail); // Send Mail
}
osThreadYield(); // suspend thread
}
}
void GetTemperature(void const *argument)
{
T_MEAS *mptr;
Chip_ADS1248_Init();
Chip_ADS1248_SelfOffsetCal(CHIP_U1);
Chip_ADS1248_SelfOffsetCal(CHIP_U3);
while(1)
{
osSignalWait(ADS_TEMP_GET, osWaitForever);
mptr=osMailAlloc(mail, osWaitForever);
mptr->rtd1 = Chip_ADS1248_GetTemperature(CHIP_U1, RTD_1);
mptr->rtd2 = Chip_ADS1248_GetTemperature(CHIP_U1, RTD_2);
mptr->rtd3 = Chip_ADS1248_GetTemperature(CHIP_U3, RTD_3);
mptr->rtd4 = Chip_ADS1248_GetTemperature(CHIP_U3, RTD_4);
osMailPut(mail, mptr);
osThreadYield();
}
}
void Thread_Semaphore (void const *argument) {
int32_t val;
while (1) {
; // Insert thread code here...
val = osSemaphoreWait (sid_Thread_Semaphore, 10); // wait 10 mSec
switch (val) {
case osOK:
; // Use protected code here...
osSemaphoreRelease (sid_Thread_Semaphore); // Return a token back to a semaphore
break;
case osErrorResource:
break;
case osErrorParameter:
break;
default:
break;
}
osThreadYield (); // suspend thread
}
}
void RX_Thread(void const *argument)
{
uint32_t rdCnt = 0;
uint8_t i = 0;
uint8_t string_match = 1;
USB_Periph_Init();
while(1)
{
osSignalWait(USB_RCV_DATA, osWaitForever);
rdCnt = vcom_bread(&g_rxBuff[0], 256);
if(rdCnt)
{
//check if the received string is "t1t2t3t4"
string_match = 1;
for(i = 0; i < RX_STRING; i++)
{
if(g_rxBuff[i] != rx_string[i])
{
string_match = 0;
break;
}
}
//if the strings match signal GetTemperature() thread
if(string_match == 1)
{
osSignalSet(get_temperature_id, ADS_TEMP_GET);
}
osThreadYield();
}
}
}
osStatus Thread::yield() {
return osThreadYield();
}
/*!
\brief Thread definition for thread 2.
\param argument A pointer to the list of arguments.
*/
void thread2 (void const *argument)
{
if (addTraceProtected("thread2 start run") != TRACE_OK)
{
stop_cpu;
}
while (1)
{
if (addTraceProtected("thread2 take sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if ( osSemaphoreWait (sid_Semaphore0, osWaitForever) != -1 ) // wait forever
{
if (addTraceProtected("thread2 take sem0 success") != TRACE_OK)
{
stop_cpu;
}
task2(); // thread code
count1Sec();
task2();
if (addTraceProtected("thread2 release sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if (osSemaphoreRelease (sid_Semaphore0) != osOK)
{
if (addTraceProtected("thread2 release sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
}
else
{
if (addTraceProtected("thread2 take sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
if (addTraceProtected("thread2 set priority to osPriorityBelowNormal") != TRACE_OK)
{
stop_cpu;
}
osThreadSetPriority(osThreadGetId(), osPriorityBelowNormal);
if (addTraceProtected("thread2 yields") != TRACE_OK)
{
stop_cpu;
}
osThreadYield(); // suspend thread
if (addTraceProtected("thread2 back from yield") != TRACE_OK)
{
stop_cpu;
}
// This should terminate the current thread2 thread
if (Terminate_thread2() != 0)
{
stop_cpu;
}
}
}
/*! \fn void thread0 (void const *argument)
\brief Thread definition for thread 0.
\param argument A pointer to the list of arguments.
*/
void thread0 (void const *argument)
{
if (addTraceProtected("thread0 start run") != TRACE_OK)
{
stop_cpu;
}
while (1)
{
if (addTraceProtected("thread0 take sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if ( osSemaphoreWait (sid_Semaphore0, 0) != -1 ) // no wait
{
if (addTraceProtected("thread0 take sem0 success") != TRACE_OK)
{
stop_cpu;
}
task0(); // thread code
count1Sec();
task0();
if (addTraceProtected("thread0 set priority to osPriorityLow") != TRACE_OK)
{
stop_cpu;
}
osThreadSetPriority(osThreadGetId(), osPriorityLow);
if (addTraceProtected("thread0 yields") != TRACE_OK)
{
stop_cpu;
}
osThreadYield(); // suspend thread
if (addTraceProtected("thread0 release sem0 attempt") != TRACE_OK)
{
stop_cpu;
}
if (osSemaphoreRelease (sid_Semaphore0) != osOK)
{
if (addTraceProtected("thread0 release sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
else
{
if (addTraceProtected("thread0 release sem0 success") != TRACE_OK)
{
stop_cpu;
}
}
}
else
{
if (addTraceProtected("thread0 take sem0 fail") != TRACE_OK)
{
stop_cpu;
}
}
if (addTraceProtected("thread0 set priority to osPriorityLow") != TRACE_OK)
{
stop_cpu;
}
osThreadSetPriority(osThreadGetId(), osPriorityLow);
if (addTraceProtected("thread0 yields") != TRACE_OK)
{
stop_cpu;
}
osThreadYield(); // suspend thread
if (addTraceProtected("thread0 back from yield") != TRACE_OK)
{
stop_cpu;
}
if (addTraceProtected("thread0 delete sem0") != TRACE_OK)
{
stop_cpu;
}
if (Delete_Semaphore0() != 0)
{
stop_cpu;
}
// This should terminate the current thread0 thread
if (Terminate_thread0() != 0)
{
stop_cpu;
}
}
}
/********* SHEULL MAIN LOOP ***********************************/
void shell_main(void *arg) {
int i ;
func_args args ;
int bf_flg ;
osThreadId cmd ;
i = BackGround ;
/* Dummy for avoiding warning: BackGround is defined but not used. */
#if defined(HAVE_KEIL_RTX)
wc_InitMutex(&command_mutex) ;
#endif
help_comm(NULL) ;
printf("Starting Shell\n") ;
while(1) {
if(getline(line, LINESIZE, &args, &bf_flg) > 0) {
for(i=0; commandTable[i].func != NULL; i++) {
if(strcmp(commandTable[i].command, args.argv[0]) == 0) {
args.argv[0] = (char *) commandTable[i].func ;
if(bf_flg == FORGROUND) {
#if defined(HAVE_KEIL_RTX) && !defined(WOLFSSL_CMSIS_RTOS)
wc_UnLockMutex((wolfSSL_Mutex *)&command_mutex) ;
os_tsk_create_user_ex( (void(*)(void *))&command_invoke, 7,
command_stack, COMMAND_STACK_SIZE, &args) ;
os_tsk_pass ();
#else
#if defined(WOLFSSL_CMSIS_RTOS)
wc_UnLockMutex((wolfSSL_Mutex *)&command_mutex) ;
cmd = osThreadCreate (osThread (command_invoke) , &args);
if(cmd == NULL) {
printf("Cannon create command thread\n") ;
}
osThreadYield ();
#else
command_invoke(&args) ;
#endif
#endif
#ifdef HAVE_KEIL_RTX
wc_LockMutex((wolfSSL_Mutex *)&command_mutex) ;
#endif
} else {
#if (!defined(NO_SIMPLE_SERVER) && \
!defined(NO_ECHOSERVER)) && \
defined(HAVE_KEIL_RTX)
if(BackGround != 0) {
printf("Multiple background servers not supported.\n") ;
} else {
printf("\"%s\" is running with the background mode.\n",
commandTable[i].command) ;
#if defined(HAVE_KEIL_RTX) && !defined(WOLFSSL_CMSIS_RTOS)
os_tsk_create_user_ex( (void(*)(void *))&bg_job_invoke,
6, bg_job_stack, BG_JOB_STACK_SIZE, &args) ;
#else
osThreadCreate (osThread (bg_job_invoke), &args);
osDelay (500) ;
#endif
}
#else
printf("Invalid Command: no background job\n") ;
#endif
}
break ;
}
}
if(commandTable[i].func == NULL)
printf("Command not found\n") ;
}
}
}
void TH_GUI (void const *argument) {
static volatile uint16_t i=0;
static uint16_t Triggered_Sample=0;
osEvent evt;
GUI_MEMDEV_Handle hMem0;
GUI_SelectLayer(0);
hMem0 = GUI_MEMDEV_Create(0,0,480,272);
if(!GUI_CURSOR_GetState())
GUI_CURSOR_Select(&GUI_CursorCrossM);
GUI_CURSOR_Show();
while (1) {
Anal_CH1_Set(/*Main loop start*/);
Anal_CH2_Set(/*Wait start*/);
evt = osSignalWait(DMA_ConvCpltSig,(uint32_t)2);
if( evt.status == osEventTimeout)
Error_Handler();
Anal_CH2_Reset(/*Wait finish*/);
//osSignalSet(tid_Touch,GUI_TouchStateReqSig);
Anal_CH3_Set(/*Copy start*/);
for(i=0;i<ADC_BUFFER_LENGTH;i++) // <- Temporary. Take the full advantage of DMA !
values_BUF[i]=255-values[i];
Anal_CH3_Reset(/*Copy finish*/);
HAL_ADC_Start_DMA(&g_AdcHandle, values, ADC_BUFFER_LENGTH);
osSignalClear(tid_TH_GUI, DMA_ConvCpltSig);
Anal_CH4_Set(/*Wait start*/);
osSignalWait(GUI_TouchGetSig,(uint32_t)0);
GUI_CURSOR_SetPosition(g_Touched.pState->x,g_Touched.pState->y);
Anal_CH4_Reset(/*Wait finish*/);
Trigger_Point = g_Touched.MSG;
Triggered_Sample = Trigger(Trigger_Point, values_BUF, ADC_BUFFER_LENGTH, 1348000UL);
//if(Triggered_Sample >=20)Triggered_Sample -=20; // Offset to see the edge in the center <- bullshit ?
GUI_MEMDEV_Select(hMem0);
GUI_MEMDEV_Clear(hMem0);
GUI_SetColor(GUI_DARKGRAY);
GUI_FillRect(0,0,480,272);
GUI_SetColor(GUI_BLACK);
GUI_DrawRect(34,5,474,266);
GUI_SetColor(GUI_WHITE);
GUI_FillRect(35,6,475,266);
Draw_GraphGrid(440,260,40,40);
GUI_SetColor(GUI_BLUE);
/*Draw garph start*/HAL_GPIO_TogglePin(GPIOI,GPIO_PIN_1);
GUI_DrawGraph((short*)&values_BUF[Triggered_Sample],440,35,6); // Useful: GUI_COUNTOF(values)
/*Draw garph finish*/HAL_GPIO_TogglePin(GPIOI,GPIO_PIN_1);
GUI_SetColor(GUI_ORANGE);
GUI_DrawHLine(Trigger_Point,0,480);
GUI_FillCircle(15,Trigger_Point,10);
GUI_SetColor(GUI_YELLOW);
GUI_DrawCircle(15,Trigger_Point,10);
GUI_MEMDEV_CopyToLCD(hMem0);
Anal_CH1_Reset(/*Main loop finish*/);
osThreadYield (); // suspend thread
}
}
void osSwitchTask(void)
{
//Force a context switch
osThreadYield();
}
void MainThread (void const *argument) {
static uint16_t last_pic_id = 0;
static MENU_ID last_menu_id = MENU_ID_MENU;
LaserDiodeInput_Init(pic_id);
SolidStateLaserInput_Init(pic_id);
LongPulseLaserInput_Init(pic_id);
GetDateTime(g_wDGUSTimeout, &datetime);
while (1) {
; // Insert thread code here...
pic_id = GetPicId(g_wDGUSTimeout, pic_id);
GetDateTime(g_wDGUSTimeout, &datetime);
last_menu_id = MenuID;
UpdateLaserState(pic_id);
LaserID = GetLaserID();
// GUI Frames process
switch (pic_id)
{
case FRAME_PICID_LOGO:
SetPicId(FRAME_PICID_MAINMENU, g_wDGUSTimeout);
break;
// Frames process
case FRAME_PICID_PASSWORD:
PasswordFrame_Process(pic_id);
break;
case FRAME_PICID_SERVICE_SOLIDSTATELASER:
ServiceFrame_Process(pic_id);
break;
case FRAME_PICID_SERVICE_LASERDIODE:
ServiceDiodeFrame_Process(pic_id);
break;
case FRAME_PICID_SERVICE_BASICSETTINGS: break; // Blank picture, for future release
case FRAME_PICID_SERVICECOOLING:
CoolingServiceFrame_Process(pic_id);
UpdateLaserStatus();
break;
// Laser Diode control
case FRAME_PICID_LASERDIODE_INPUT:
#ifdef LASERIDCHECK_LASERDIODE
if (GetLaserID() == LASER_ID_DIODELASER)
{
if (last_pic_id != pic_id && last_menu_id != MenuID)
LaserDiodeInput_Init(pic_id);
LaserDiodeInput_Process(pic_id);
}
else
SetPicId(FRAME_PICID_WRONG_EMMITER, g_wDGUSTimeout);
#else
if (last_pic_id != pic_id && last_menu_id != MenuID)
LaserDiodeInput_Init(pic_id);
LaserDiodeInput_Process(pic_id);
#endif
UpdateLaserStatus();
break;
case FRAME_PICID_LASERDIODE_TEMPERATUREOUT:
case FRAME_PICID_LASERDIODE_PREPARETIMER:
case FRAME_PICID_LASERDIODE_FLOWERROR:
LaserDiodePrepare_Process(pic_id);
UpdateLaserStatus();
break;
case FRAME_PICID_LASERDIODE_READY:
case FRAME_PICID_LASERDIODE_START:
case FRAME_PICID_LASERDIODE_STARTED:
LaserDiodeWork_Process(pic_id);
case FRAME_PICID_LASERDIODE_PHOTOTYPE:
UpdateLaserStatus();
break;
// WiFi features
case FRAME_PICID_SERVICE_WIFISCANNINGINIT:
WifiScanningFrame_Init(pic_id);
break;
case FRAME_PICID_SERVICE_WIFISCANNING:
WifiScanningFrame_Process(pic_id);
break;
case FRAME_PICID_SERVICE_WIFIAUTHENTICATION:
WifiAuthenticationFrame_Process(pic_id);
break;
case FRAME_PICID_WIFI_LINKING:
WiFiLinkFrame_Process();
break;
// App idle user state
case FRAME_PICID_MAINMENU:
if (ip_addr_updated)
{
WriteVariable(FRAMEDATA_WIFIUP_IPADDR, ip_addr, 16);
osSignalWait(DGUS_EVENT_SEND_COMPLETED, g_wDGUSTimeout);
ip_addr_updated = false;
}
StopIfRunning(last_pic_id);
case FRAME_PICID_SERVICE:
case FRAME_PICID_LANGMENU:
// nothing to do
break;
// Solid State Laser
case FRAME_PICID_SOLIDSTATE_INPUT:
if (last_pic_id != pic_id && last_menu_id != MenuID)
SolidStateLaserInput_Init(pic_id);
if (GetLaserID() == LASER_ID_SOLIDSTATE || GetLaserID() == LASER_ID_SOLIDSTATE2)
SolidStateLaserInput_Process(pic_id);
else
SetPicId(FRAME_PICID_WRONG_EMMITER, g_wDGUSTimeout);
UpdateLaserStatus();
break;
case FRAME_PICID_SOLIDSTATE_SIMMERSTART:
case FRAME_PICID_SOLIDSTATE_SIMMER:
case FRAME_PICID_SOLIDSTATE_START:
case FRAME_PICID_SOLIDSTATE_WORK:
SolidStateLaserWork_Process(pic_id);
UpdateLaserStatus();
break;
case FRAME_PICID_SOLIDSTATE_FLOWERROR:
case FRAME_PICID_SOLIDSTATE_OVERHEATING:
case FRAME_PICID_SOLIDSTATE_FAULT:
SolidStateLaserPrepare_Process(pic_id);
UpdateLaserStatus();
break;
// Long Pulse Laser
case FRAME_PICID_LONGPULSE_INPUT:
if (last_pic_id != pic_id && last_menu_id != MenuID)
LongPulseLaserInput_Init(pic_id);
LongPulseLaserInput_Process(pic_id);
UpdateLaserStatus();
/*
if (GetLaserID() == LASER_ID_LONGPULSE)
LongPulseLaserInput_Process(pic_id);
else
SetPicId(FRAME_PICID_WRONG_EMMITER, g_wDGUSTimeout);*/
break;
case FRAME_PICID_LONGPULSE_SIMMERSTART:
case FRAME_PICID_LONGPULSE_SIMMER:
if (GetLaserID() == LASER_ID_LONGPULSE)
LongPulseLaserWork_Process(pic_id);
else
SetPicId(FRAME_PICID_WRONG_EMMITER, g_wDGUSTimeout);
UpdateLaserStatus();
break;
case FRAME_PICID_LONGPULSE_START:
case FRAME_PICID_LONGPULSE_WORK:
LongPulseLaserWork_Process(pic_id);
UpdateLaserStatus();
break;
case FRAME_PICID_LONGPULSE_FLOWERROR:
case FRAME_PICID_LONGPULSE_OVERHEATING:
case FRAME_PICID_LONGPULSE_FAULT:
LongPulseLaserPrepare_Process(pic_id);
UpdateLaserStatus();
break;
case FRAME_PICID_BASICSETTINGS:
UpdateLaserStatus();
break;
case FRAME_PICID_LOGVIEW:
LogFrame_Process(pic_id);
break;
case FRAME_PICID_WRONG_EMMITER:
osDelay(800);
SetPicId(FRAME_PICID_MAINMENU, g_wDGUSTimeout);
break;
case FRAME_PICID_REMOTECONTROL:
break;
default:
SetPicId(FRAME_PICID_MAINMENU, g_wDGUSTimeout);
break;
}
// Remote control
if (RemoteControl)
{
if (pic_id == FRAME_PICID_MAINMENU)
SetPicId(FRAME_PICID_REMOTECONTROL, g_wDGUSTimeout);
}
else
if (pic_id == FRAME_PICID_REMOTECONTROL)
{
SetPicId(FRAME_PICID_MAINMENU, g_wDGUSTimeout);
//pic_id = FRAME_PICID_MAINMENU;
}
last_pic_id = pic_id;
osThreadYield (); // suspend thread
}
}
