Пример #1
0
/* this is a simple program which runs in a thread */
void simple_program(cyg_addrword_t data)
{
    int message = (int) data;
    int delay;

    cyg_mutex_lock(&cliblock);
    printf("Beginning execution; thread data is %d\n", message);
    cyg_mutex_unlock(&cliblock);

    cyg_thread_delay(200);

    for (;;) {
        /* delay = 1000 + (rand() % 50); */
        delay = 5000*(1+message) + (rand() % 50);

        /* note: printf() must be protected by a
           call to cyg_mutex_lock() */
        cyg_mutex_lock(&cliblock);

        {
            cyg_tick_count_t tick;
            tick = cyg_current_time();
            #if 0
            printf("(%llu) Thread %d: and now a delay of %d clock ticks\n",
                        tick, message, delay);
            #else
//            printf("(%llu) Thread %d\n", tick, message);
            #endif

        }

        cyg_mutex_unlock(&cliblock);
        cyg_thread_delay(delay);
    }
}
void  _enter_critical_ex(_lock *plock, _irqL *pirqL)
{
	//eason 20100210 spin_lock_irqsave(plock, *pirqL);
	cyg_mutex_t * mut_t = plock;	
	*pirqL = dirps();	
	cyg_mutex_lock(mut_t);
}
Пример #3
0
void worker( cyg_addrword_t id )
{
    for(;;)
    {
        thread_count[id]++;
        thread_pri[id] = cyg_thread_get_priority( cyg_thread_self() );
        
        switch( worker_state )
        {
        case WORKER_STATE_BREAK:
            if( 0 == (id % 4) )
                breakme();
            
        case WORKER_STATE_WAIT:
            cyg_mutex_lock( &worker_mutex );
            workers_asleep++;
            cyg_cond_wait( &worker_cv );
            workers_asleep--;
            cyg_mutex_unlock( &worker_mutex );
            break;

        case WORKER_STATE_EXIT:
            cyg_thread_exit();
            
        }
    }
}
Пример #4
0
Файл: 4.c Проект: rednuk/Temp
void res_free(res_t res)
{
    cyg_mutex_lock(&res_lock);
    res_pool[res_count] = res;
    res_count++;
    printf("TID %lu freeing %d, free resources: %d\n", cyg_thread_self(), res, res_count);
    cyg_mutex_unlock(&res_lock);
}
Пример #5
0
static int 
e_mutex_lock(lua_State *L) 
{
    cyg_mutex_t *mx;
    mx = (cyg_mutex_t *) check_user_data(L, 1, E_MUTEX);
    lua_pushboolean(L, cyg_mutex_lock(mx));
    return 1;
}
Пример #6
0
void resFree(res_t res)
{
    cyg_mutex_lock(&res_lock);
    res_pool[res_count]=res;
    res_count++;
    cyg_cond_signal(&res_wait);
    cyg_mutex_unlock(&res_lock);
}
Пример #7
0
void vjpegLock (void)
{
#ifndef ECOS
	tt_rmutex_lock (&g_vpJPEG.mtLock);
#else
	cyg_mutex_lock (&g_vpJPEG.mtLock);
#endif
}
Пример #8
0
static void finish( cyg_ucount8 t )
{
    cyg_mutex_lock( &m1 ); {
        m1d |= 1<<t;
        if( 0x7 == m1d )
            CYG_TEST_PASS_FINISH("Kernel C API Mutex 1 OK");
        cyg_cond_wait( &cvar2 );
    } /* cyg_mutex_unlock( &m1 ); */
    CYG_TEST_FAIL_FINISH("Not reached");    
}
Пример #9
0
char get_state( int id)
{
    char s;
    cyg_mutex_lock(&state_mutex);
    
    s = pstate[id];

    cyg_mutex_unlock(&state_mutex);

    return s;
}
Пример #10
0
void GetCheckedTime(long *plTime1970_InSec, long *plTimeZone_InSec)
{
	//pthread_mutex_lock(&g_ptmTimeSetting);
	cyg_mutex_lock(&g_ptmTimeSetting);
	if (plTime1970_InSec != NULL)
		*plTime1970_InSec = mytime() + g_lTimeDelay1970_InSec;
	if (plTimeZone_InSec != NULL)
		*plTimeZone_InSec = GetSystemTimeZone() + g_lTimeDelayZone_InSec;
	//pthread_mutex_unlock(&g_ptmTimeSetting);
	cyg_mutex_unlock(&g_ptmTimeSetting);
}
Пример #11
0
res_t resAllocate(void)
{
    res_t res;
    cyg_mutex_lock(&res_lock);
    while(res_count == 0)
        cyg_cond_wait(&res_wait);
    res_count--;
    res = res_pool[res_count];
    cyg_mutex_unlock(&res_lock);
    return res;
}
Пример #12
0
int main( int argc, char *argv[] )
{
	int i;
	HAL_DCACHE_ENABLE();

	printf("begin mutex_test_ecos\n");

	cyg_mutex_init(&mutex);
	cyg_mutex_lock(&mutex);

	printf("creating hw thread... ");
	
	cyg_thread_resume(ECOS_HWT_CREATE(0,0,thread_resources));
	printf("ok\n");
	
	for(i = 0; i < 10; i++){
		unsigned long ticks = cyg_current_time();
		//printf("current time = %ld ticks\n",ticks); // XXX remove
		cyg_mutex_unlock(&mutex);
		while(cyg_current_time() - ticks < 10); // wait for 0.1 seconds
		cyg_mutex_lock(&mutex);
		ticks = cyg_current_time() - ticks;
		//printf("delta t = %ld ticks\n", ticks); // XXX remove
		
		printf("mutex lock and release by hwthread: ");
		if(ticks > 20 && ticks < 40){
			printf("success\n");
		}
		else if(ticks <= 20){
			printf("too early\n"); // should not happen
		}
		else {
			printf("too late\n"); // should not happen
		}
		cyg_thread_delay(50);
	}
	
	printf("mutex_test_ecos done.\n");
	
	return 0;
}
Пример #13
0
static void entry2( cyg_addrword_t data )
{
    cyg_mutex_lock( &m0 ); {
        while( 3 != m0d ) {
            cyg_cond_wait( &cvar0 );
        }
        CHECK( 3 == m0d++ );
        cyg_cond_broadcast( &cvar1 );
    } cyg_mutex_unlock( &m0 );

    finish( (cyg_ucount8)data );
}
Пример #14
0
static void entry0( cyg_addrword_t data )
{
    cyg_mutex_lock( &m0 ); {
        CHECK( ! cyg_mutex_trylock( &m0 ) );
        cyg_mutex_lock( &m1 ); {
            CHECK( ! cyg_mutex_trylock( &m0 ) );            
        } cyg_mutex_unlock( &m1 );
    } cyg_mutex_unlock( &m0 );

    cyg_mutex_lock( &m0 ); {
        while ( 0 == m0d )
            cyg_cond_wait( &cvar0 );
        CHECK( 1 == m0d++ );
        cyg_cond_signal( &cvar0 );
        while ( 4 != m0d )
            cyg_cond_wait( &cvar1 );
        CHECK( 4 == m0d );
    } cyg_mutex_unlock( &m0 );

    finish( (cyg_ucount8)data );
}
Пример #15
0
static void entry1( cyg_addrword_t data )
{
    cyg_mutex_lock( &m0 ); {
        CHECK( cyg_mutex_trylock( &m1 ) ); {
        } cyg_mutex_unlock( &m1 );
    } cyg_mutex_unlock( &m0 );

    cyg_mutex_lock( &m0 ); {
        CHECK( 0 == m0d++ );
        cyg_cond_broadcast( &cvar0 );
    } cyg_mutex_unlock( &m0 );
    
    cyg_mutex_lock( &m0 ); {
        while( 1 == m0d )
            cyg_cond_wait( &cvar0 );
        CHECK( 2 == m0d++ );
        cyg_cond_signal( &cvar0 );
        while( 3 == m0d )
            cyg_cond_wait( &cvar1 );
    } cyg_mutex_unlock( &m0 );

    finish( (cyg_ucount8)data );
}
Пример #16
0
Файл: 4.c Проект: rednuk/Temp
res_t res_allocate()
{
    res_t res;
    cyg_mutex_lock(&res_lock);
    
    while (res_count == 0)
        cyg_cond_wait(&res_wait, &res_lock);
    res_count--;
    res = res_pool[res_count];
    printf("TID %lu using %d, free resources: %d\n", cyg_thread_self(), res, res_count);
    cyg_cond_signal(&res_wait);
    
    cyg_mutex_unlock(&res_lock);
    return res;
}
Пример #17
0
void simple_programB(cyg_addrword_t data)
{
    int msg = (int) data;
    int delay;
    printf("Starting thread : %d\n",msg);
    cyg_thread_delay(200);
    for(;;)
    {
        delay = 200 + (rand()%50);
        resFree(resAllocated);
        cyg_mutex_lock(&mut_t);
        printf("Allocating resource for thread %d\n", msg);
        cyg_mutex_unlock(&mut_t);
        cyg_thread_delay(delay);
    }
}
Пример #18
0
static inline cyg_uint32
spl_any( cyg_uint32 which )
{
    cyg_uint32 old_spl = spl_state;
    if ( cyg_thread_self() != splx_thread ) {
        cyg_mutex_lock( &splx_mutex );
        old_spl = 0; // Free when we unlock this context
        CYG_ASSERT( 0 == splx_thread, "Thread still owned" );
        CYG_ASSERT( 0 == spl_state, "spl still set" );
        splx_thread = cyg_thread_self();
    }
    CYG_ASSERT( splx_mutex.locked, "spl_any: mutex not locked" );
    CYG_ASSERT( (cyg_handle_t)splx_mutex.owner == cyg_thread_self(),
                "spl_any: mutex not mine" );
    spl_state |= which;
    return old_spl;
}
Пример #19
0
void usbTerm::rx_thread_func(cyg_addrword_t arg)
{
	diag_printf("USB started\n");

	for(;;)
	{
		cyg_mutex_lock(&(__instance->mUSBmutex));
		if(cyg_cond_timed_wait(&(__instance->mUSBrxCond), cyg_current_time() + 5000)) //keep the thread running to prevent lock ups
		{
			if(__instance->mUSBRXlen)
			{
				__instance->handleData(__instance->mUSBRXbuff, __instance->mUSBRXlen);
			}
		}

		cyg_mutex_unlock(&(__instance->mUSBmutex));
	}
}
void	_spinlock_ex(_lock	*plock)
{

#ifdef PLATFORM_LINUX

	//eason 20100210 spin_lock(plock);
	cyg_mutex_t * mut_t = plock;	
	cyg_mutex_lock(mut_t);

#endif
	
#ifdef PLATFORM_WINDOWS

	NdisDprAcquireSpinLock(plock);

#endif
	
}
Пример #21
0
cyg_uint16  usbTerm::cdc_rxData(cyg_uint8* buff, cyg_uint32 len)
{
	//diag_printf("RX %d\n", len);
	if(!__instance)
		return USBD_FAIL;

	if(!(len && (len < 512)))
		return USBD_FAIL;

	cyg_mutex_lock(&(__instance->mUSBmutex));
	memcpy(__instance->mUSBRXbuff, buff, len);
	__instance->mUSBRXlen = len;
	cyg_mutex_unlock(&(__instance->mUSBmutex));

	cyg_cond_signal(&(__instance->mUSBrxCond));


	return USBD_OK;
}
Пример #22
0
int Config_SetFtp(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML)
{
	switch (iAction)
	{
	case CA_AUTH:
		return AUTH_ADMIN;
		break;
	case CA_CONFIG:
		cyg_mutex_lock(&g_ptmConfigParam);
		if (httpIsExistParam(pParamList, "FtpServer"))
			httpMyStrncpy(g_ConfigParam.acFtpServer, httpGetString(pParamList, "FtpServer"), sizeof(g_ConfigParam.acFtpServer));
		if (httpIsExistParam(pParamList, "User"))
			httpMyStrncpy(g_ConfigParam.acFtpUser, httpGetString(pParamList, "User"), sizeof(g_ConfigParam.acFtpUser));
		if (httpIsExistParam(pParamList, "Pass"))
			httpMyStrncpy(g_ConfigParam.acFtpPass, httpGetString(pParamList, "Pass"), sizeof(g_ConfigParam.acFtpPass));
		if (httpIsExistParam(pParamList, "Account"))
			httpMyStrncpy(g_ConfigParam.acFtpAccount, httpGetString(pParamList, "Account"), sizeof(g_ConfigParam.acFtpAccount));
		if (httpIsExistParam(pParamList, "UploadPath"))
		{
			char *pcPath;
			pcPath = GetRegPath(httpGetString(pParamList, "UploadPath"));
			if (pcPath == NULL) g_ConfigParam.acFtpUploadPath[0] = '\0';
			else
			{
				httpMyStrncpy(g_ConfigParam.acFtpUploadPath, pcPath, sizeof(g_ConfigParam.acFtpUploadPath));
				free(pcPath);
			}
		}
		if (httpIsExistParam(pParamList, "Enable"))
			g_ConfigParam.bFtpEnable = httpGetBool(pParamList, "Enable");
		else g_ConfigParam.bFtpEnable = FALSE;
		g_WebCamState.ucFtp = (g_ConfigParam.bFtpEnable?'\1':'\0');
		cyg_mutex_unlock(&g_ptmConfigParam);

		WebCameraLog(CL_PRIVILEGE_ADMIN, CL_SET_FTP, g_ConfigParam.acFtpServer, hConnection);

		WriteFlashMemory(&g_ConfigParam);

		return 0;
		break;
	}
	return -1;
}
Пример #23
0
bool cyg_recursive_mutex_lock( cyg_recursive_mutex_t *mx )
{
  bool result = false;
  cyg_scheduler_lock();
  {
    if( cyg_thread_self() == mx->owner )
      {
          mx->count++;
          result = true;
      }
    else
      {
          result = cyg_mutex_lock( &mx->mutex );
          mx->count = 1;
          mx->owner = cyg_thread_self();
      }
  }
  cyg_scheduler_unlock();
  return result;
}
Пример #24
0
int Config_GetStatus(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML)
{
	char pcBuf[128];

	switch (iAction)

	{

	case CA_AUTH:
		return AUTH_USER;
	case CA_CONFIG:
		SetRunTimeState(hConnection);
		cyg_mutex_lock(&g_ptmState);
		GetWebCamStateString(&g_WebCamState, pcBuf);
		cyg_mutex_unlock(&g_ptmState);
		AddHttpValue(pReturnXML, "Status", pcBuf);
		return 0;
	}
	return -1;
}
Пример #25
0
///
/// Load a bitstream via ICAP
///
/// @param bitstream pointer to the bitstream array
/// @param length    length of bitstream in bytes
///
void icap_load(unsigned char * bitstream, size_t length){

        XStatus status;

        if (!cyg_mutex_lock(&icap_mutex)) {
            CYG_FAIL("mutex lock failed, aborting thread\n");
        } else {

            // wait until ICAP is ready
            while (HwIcap.IsTransferInProgress) {
                diag_printf("icap_load(): transfer in progress, waiting...\n");
                cyg_thread_delay(1);
            }
            while (! (XHwIcap_GetStatusReg(&HwIcap) & XHI_SR_DONE_MASK)) {
                diag_printf("icap_load(): device busy, waiting...\n");
                cyg_thread_delay(1);
            }

            status = XHwIcap_DeviceWrite(&HwIcap, (Xuint32*)bitstream, length/4);
            if (status != XST_SUCCESS)
            {
                if(status == XST_DEVICE_BUSY) diag_printf("HWICAP: device busy\n");
                if(status == XST_INVALID_PARAM) diag_printf("HWICAP: invalid parameter\n");
                CYG_FAIL("failed to load bitstream\naborting\n");
            }

            // wait until ICAP is ready
            while (HwIcap.IsTransferInProgress) {
                diag_printf("icap_load(): transfer in progress, waiting...\n");
                cyg_thread_delay(1);
            }
            while (! (XHwIcap_GetStatusReg(&HwIcap) & XHI_SR_DONE_MASK)) {
                diag_printf("icap_load(): device busy, waiting...\n");
                cyg_thread_delay(1);
            }

            cyg_mutex_unlock(&icap_mutex);
        }
}
Пример #26
0
void change_state(int id, char newstate)
{
    cyg_mutex_lock(&state_mutex);

#ifdef CYG_HAL_MN10300_MN103002
    if( pstate[id] == 'E' ) eaters--;
    if( newstate == 'E' ) eaters++;
//    led(eaters);
#endif
    
    pstate[id] = newstate;

    diag_write_string(pstate);
#if 0
    diag_write_char(' ');
    diag_write_dec(Cyg_Scheduler::get_thread_switches());
#endif    
    diag_write_char('\n');

    cyg_mutex_unlock(&state_mutex);
    
}
Пример #27
0
void SetCheckedTime(const long *plTime1970_InSec, const long *plTimeZone_InSec)
{
	struct tm tms;
	time_t current_time;
	//pthread_mutex_lock(&g_ptmTimeSetting);
	cyg_mutex_lock(&g_ptmTimeSetting);

	if (plTime1970_InSec != NULL)
		g_lTimeDelay1970_InSec = *plTime1970_InSec - mytime();
	
	if (plTimeZone_InSec != NULL)
		g_lTimeDelayZone_InSec = *plTimeZone_InSec - GetSystemTimeZone();
	
	current_time =  time (0);
	 current_time += g_lTimeDelay1970_InSec - g_lTimeDelayZone_InSec;
	  current_time +=  GetSystemTimeZone ();
	gmtime_r (&current_time, &tms);
	
	wb702SetDateTime (&tms);

	cyg_mutex_unlock(&g_ptmTimeSetting);
}
Пример #28
0
/* this is a simple program which runs in a thread */
void simple_program(cyg_addrword_t data)
{
 int message = (int) data;
 int delay;

  printf("Beginning execution; thread data is %d\r\n", message);

 cyg_thread_delay(200);

 for (;;) {
 delay = 200 + (rand() % 50);

 /* note: diag_printf() must be protected by a
 call to cyg_mutex_lock() */
 cyg_mutex_lock(&cliblock); {
 printf("Thread %d: and now a delay of %d clock ticks\r\n",
	message, delay);
 }
 cyg_mutex_unlock(&cliblock);
 cyg_thread_delay(delay);
 }
}
Пример #29
0
BOOL SaveJpeg(char *pcJpeg, int iJpegLen, BOOL bIsMotionDetected)
{
	int iNextReadyImg;
	int iNextPicIndex; 
	int iNextMotionDetectedIndex;

	/* 设置新的抓到的图像在g_WebCamState.acImgBuf总的序号 */
	iNextReadyImg = g_WebCamState.iReadyImg + 1;
	if (iNextReadyImg >= 2) iNextReadyImg = 0;

	/* 设置新的图像序号 */
	if (g_WebCamState.uiPicIndex == INVALID_PICTURE)
		iNextPicIndex = 0;
	else iNextPicIndex = g_WebCamState.uiPicIndex + 1;
	if (iNextPicIndex >= MAX_IMG_INDEX) iNextPicIndex = 0;

	/* 设置新的motion detect序号 */
	if (g_WebCamState.uiPicMotionDetectedIndex == INVALID_PICTURE)
		iNextMotionDetectedIndex = 0;
	else iNextMotionDetectedIndex = g_WebCamState.uiPicMotionDetectedIndex + 1;
	if (iNextMotionDetectedIndex >= MAX_IMG_INDEX) iNextMotionDetectedIndex = 0;

	
	cyg_mutex_lock(&g_ptmState);
	g_WebCamState.iReadyImg = iNextReadyImg;
	g_WebCamState.uiPicIndex = iNextPicIndex;
	g_WebCamState.uiPicSize = iJpegLen;
	//g_WebCamState.ucBright = g_ConfigParam.ulImgBrightness;
	g_WebCamState.ucContrast = g_ConfigParam.ulImgContrast;
	g_WebCamState.ucSaturation = g_ConfigParam.ulImgSaturation;
	g_WebCamState.ucHue = g_ConfigParam.ulImgHue;
	g_WebCamState.ucSharpness = g_ConfigParam.ulImgSharpness;
	if (bIsMotionDetected)
		g_WebCamState.uiPicMotionDetectedIndex = iNextMotionDetectedIndex;
	cyg_mutex_unlock(&g_ptmState);
	vcptJpegTimerAck();
	return TRUE;
}
Пример #30
0
void Do_TestSendMail(LIST **pplPic2Mail, time_t *ptLastMail, BOOL bForceSend)
{
	char *pcContent;
	int i;
	int iLenList;
	time_t tThisMail;

	iLenList = httpGetListLength(*pplPic2Mail);
	cyg_mutex_lock(&g_ptmConfigParam);
	tThisMail = mytime();

	if ( iLenList > 0 &&
		(bForceSend || iLenList >= MAX_IMAGE_IN_ON_MAIL || tThisMail - *ptLastMail > 10))
	{
		if (g_ConfigParam.acMailSender[0] != '\0'
			&& g_ConfigParam.acMailReceiver[0] != '\0'
			&& g_ConfigParam.acMailServer[0] != '\0')
		{
			int j;
			LISTNODE *pNode;
			FILE_BUF_T *pFb;
			MAIL_MEM* mail_mem = NULL;

			pcContent = malloc(256 * iLenList
				+ strlen(g_cst_pcHtmlTemplate1)
				+ strlen(g_cst_pcHtmlTemplate2));
			if (pcContent != NULL)
			{
				j = 0;
				j += sprintf(pcContent+j, "%s", g_cst_pcHtmlTemplate1);

				if (*pplPic2Mail != NULL)
				{
					for (i=0, pNode = (*pplPic2Mail)->pFirstNode; pNode != (*pplPic2Mail)->pLastNode && i<iLenList; pNode = pNode->pNextNode, i++)
					{
						pFb = (FILE_BUF_T *)pNode->pValue;
						if (pFb)
						{
							char acTime[32];
							time_t tRealTime;
							struct tm tmGRealTime;
							cyg_mutex_lock(&g_ptmTimeSetting);
							tRealTime = pFb->st.st_mtime + g_lTimeDelay1970_InSec - (GetSystemTimeZone() + g_lTimeDelayZone_InSec);
							cyg_mutex_unlock(&g_ptmTimeSetting);
							//cyg_thread_yield();
							gmtime_r(&tRealTime, &tmGRealTime);
							asctime_r(&tmGRealTime, acTime);
							j += sprintf(pcContent+j, "<font id=oTimeList>%s:</font><br><img id=oImgList src='cid:Attachment%d'><p>", acTime, i);
						}
					}
				}
				j += sprintf(pcContent+j, "%s", g_cst_pcHtmlTemplate2);				
			
				if(get_mail_mem(&mail_mem) == FALSE)
					diag_printf("Not enough mail memory!\n");
				else
				{
					sendMailMsg(
						g_ConfigParam.acMailSender,
						g_ConfigParam.acMailReceiver,"","",
						(g_ConfigParam.acMailSubject[0]=='\0'?"Web Camera Warning!":g_ConfigParam.acMailSubject),
						pcContent,
						1,
						*pplPic2Mail,
						g_ConfigParam.acMailServer,
						g_ConfigParam.acMailUser,
						(g_ConfigParam.bMailCheck?g_ConfigParam.acMailPassword:NULL),
						MAIL_MOTION_DETECTED,
						mail_mem);
				}
				free(pcContent);
			}
			else
				PRINT_MEM_OUT;
		}
		else g_WebCamState.ucEmail = '\2';

		DeleteFileList(*pplPic2Mail);
		*pplPic2Mail = (LIST*)CreateFileList();
		*ptLastMail = tThisMail;
	}
	cyg_mutex_unlock(&g_ptmConfigParam);
	//cyg_thread_yield();
}