Exemple #1
0
int main()
{
	int l = 1;
    uint8_t c[2];

	X.output();
	Y.output();
	Z.output();
	E.output();

	setleds(l);

	if (1) {
		UART * s = new UART(0, 9600);
		s->send((uint8_t *) "Start\n", 6);

		for(;;)
		{
    		for (int i = 0 ; ((i & (1 << 22)) == 0) && !g_LoopDummy ; i++)
    		{
    		}
    		c[0] = '0' + (l & 7);
    		c[1] = '\n';
			//s->send(c, 2);
			setleds(l++);
		}
	}
}
Exemple #2
0
v8::Handle<v8::Value> GPIO::SetMode(const v8::Arguments& args) {
    v8::HandleScope scope;
    GPIO* obj = ObjectWrap::Unwrap<GPIO>(args.This());
    if (!obj->opened) {
        std::string err_msg = "GPIO " + obj->pin_num + " is not opened.";
        v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg.c_str())));
        return scope.Close(v8::Undefined());
    }
    if (args.Length() < 1) {
        v8::ThrowException(v8::Exception::TypeError(v8::String::New("Wrong number of arguments")));
        return scope.Close(v8::Undefined());
    }
    if (!args[0]->IsString()) {
        v8::ThrowException(v8::Exception::TypeError(v8::String::New("Wrong arguments")));
        return scope.Close(v8::Undefined());
    }
    std::string mode(*v8::String::Utf8Value(args[0]));
    int res = obj->setMode(mode);
    if (res < 0) {
        std::string err_msg = "OPERATION FAILED: Unable to change GPIO " + obj->pin_num + " mode.";
        v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg.c_str())));
        return scope.Close(v8::Undefined());
    }
    obj->log("GPIO " + obj->pin_num + " mode changed to " + mode + ".");
    return scope.Close(v8::Integer::New(res));
}
Exemple #3
0
void ADXL345::calibrate(GPIO light)
{

	zeroX = 0;
	zeroY = 0;
	zeroZ = 0;

	vector v;
	for (int i = 0; i < 1000; i++)
	{
		if (i % 15 == 0)
			light.toggle();

		read(v);
		zeroX += v.x;
		zeroY += v.y;
		zeroZ += (1-v.z);

		delayMillis(5);
	}

	light.low();

	zeroX /= 1000;
	zeroY /= 1000;
	zeroZ /= 1000;

	calibrated = 1;

}
Exemple #4
0
// This thread function is a friend function of the class
void* threadedPoll(void *value) {
    GPIO *gpio = static_cast<GPIO*>(value);
    while(gpio->threadRunning) {
        gpio->callbackFunction(gpio->waitForEdge());
        usleep(gpio->debounceTime * 1000);
    }
    return 0;
}
 bool run(void *p)
 {
     if (xSemaphoreTake(sem, 9999))
     {
         //p2_wire0.toggle();
         p2_wire0.setHigh();
         vTaskDelay(500);
         p2_wire0.setLow();
     }
     return true;
 }
Exemple #6
0
v8::Handle<v8::Value> GPIO::Toggle(const v8::Arguments& args)
{
    v8::HandleScope scope;
    GPIO* obj = ObjectWrap::Unwrap<GPIO>(args.This());
    std::string path = "/sys/class/gpio/gpio" + obj->pin_num + "/value";
    int value = obj->ReadValue(path);
    std::ostringstream ss;
    ss << !value;
    obj->WriteValue(path, ss.str());
    return scope.Close(v8::Integer::New(0));
}
Exemple #7
0
v8::Handle<v8::Value> GPIO::Close(const v8::Arguments& args)
{
    v8::HandleScope scope;
    GPIO* obj = ObjectWrap::Unwrap<GPIO>(args.This());
    int res = obj->close();
    if (res < 0) {
        std::string err_msg = "OPERATION FAILED: Unable to close GPIO " + obj->pin_num + ".";
        v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg.c_str())));
        return scope.Close(v8::Undefined());
    }
    obj->log("GPIO " + obj->pin_num + " closed.");
    return scope.Close(v8::Integer::New(res));
}
Exemple #8
0
// This thread function is a friend function of the class
void* threadedToggle(void *value) {
    GPIO *gpio = static_cast<GPIO*>(value);
    bool isHigh = (bool) gpio->getValue(); //find current value
    while(gpio->threadRunning) {
        if (isHigh)	gpio->setValue(GPIO::HIGH);
        else gpio->setValue(GPIO::LOW);
        usleep(gpio->togglePeriod * 500);
        isHigh=!isHigh;
        if(gpio->toggleNumber>0) gpio->toggleNumber--;
        if(gpio->toggleNumber==0) gpio->threadRunning=false;
    }
    return 0;
}
Exemple #9
0
void ledTaskCallback (OS::Task &task) {
	UNUSED(task);

	while(1){
		led1.on();
		led2.off();

		OS::sleep(500);

		led1.off();
		led2.on();

		OS::sleep(500);
	}
}
 bool init(void)
 {
     p2_wire0.setAsInput();
     SW.init();
     LE.init();
     return true;
 }
 UltrasonicSensor(LPC1758_GPIO_Type Power_Pin, bool filterOpt = false, int filterSize = 0):
     GpioPower(Power_Pin),
     avg_filter(filterSize),
     isFilterUsed(filterOpt)
 {
     /* Configuring the GpioPower pin as Output */
     GpioPower.setAsOutput();
 }
 bool init(void)
 {
     p2_wire0.setAsOutput();
     const uint8_t port2_1 = 1;
     eint3_enable_port2(port2_1, eint_rising_edge, switch_edge);
     LE.init();
     vSemaphoreCreateBinary(sem);
     return true;
 }
Exemple #13
0
		void setup(){
    			gpio26  = new GPIO("26");
			gpio19  = new GPIO("19");
			gpio13  = new GPIO("13");
			gpio6   = new GPIO("6");
			gpio21  = new GPIO("21");

			gpio26->export_gpio();
			gpio19->export_gpio();
			gpio13->export_gpio();
			gpio6->export_gpio();
			gpio21->export_gpio();

		        gpio26->setdir_gpio("out");
                        gpio19->setdir_gpio("out");
                        gpio13->setdir_gpio("out");
                        gpio6->setdir_gpio("out");
                        gpio21->setdir_gpio("in");
		}
Exemple #14
0
int main()
{
		u8 State=REMOTECONTROL_LOCK;
		u8 OldState=REMOTECONTROL_LOCK;
		double Receive_data=0;  //接收数据  10ms
		double RcUpdata=0;      //遥控器状态更新时间  20ms
		ledBlueGPIO.SetLevel(0);
	while(1)
	{	
		if(tskmgr.TimeSlice(Receive_data,0.01) ) //0.01
		{
			Hi.DataListening_SendPC();//监听飞机发送来的数据转发给PC
			Hi.DataListening_SendCopter();//监听PC发送来的数据转发给飞机
		}
		
		if(tskmgr.TimeSlice(RcUpdata,0.08) )
		{
			State=RC.Updata(80,2000);	
			Hi.SendData2Copter(RC.GetYawVal(),RC.GetThrottleVal(),RC.GetRollVal(),RC.GetPitchVal(),false);	
			
			if(State == REMOTECONTROL_LOCK &&  OldState ==REMOTECONTROL_UNLOCK )
			{
					OldState = REMOTECONTROL_LOCK;
					Hi.SendOrder(0XA0);
					ledBlueGPIO.SetLevel(1);//上锁状态为亮
			}
			else if(State ==REMOTECONTROL_UNLOCK && OldState ==REMOTECONTROL_LOCK)//解锁
			{	
					Hi.SendOrder(0XA1);
					OldState = REMOTECONTROL_UNLOCK;
					ledBlueGPIO.SetLevel(0);//解锁状态为灭
					//tskmgr.DelayS(1);
			}		
			if(State == REMOTECONTROL_UNLOCK) //如果解锁了才向上位机发送
					Hi.SendData2Copter(RC.GetYawVal(),RC.GetThrottleVal(),RC.GetRollVal(),RC.GetPitchVal(),true);			
			
			
		}	
		
	}
}
Exemple #15
0
void mainTaskCallback (OS::Task &task) {
	UNUSED(task);

	OS::sleep(100);
	en2v8.on();
	OS::sleep(100);


	OS::sleep(100);
	bluetoothShutdown.off();
	OS::sleep(100);

	Bluetooth::instance().init("MobilECG");

	//Turn on ECG clock
	TIM_HandleTypeDef tim;
	tim.Instance = TIM1;
	HAL_TIM_PWM_Start(&tim, TIM_CHANNEL_3);


	if (!ADS1298::instance().start())
		Logger::panic("Failed to initialize ADS1298.");

	while(1){
		if (!Bluetooth::instance().isConnected()){
			ADS1298::instance().clear();
			OS::sleep(10);
			continue;
		}

		if (ADS1298::instance().getAvailableData()<512){
			OS::sleep(10);
			continue;
		}

		ecgSender.send();
	}
}
void ApplicationEntryPoint()
{
    BOOL result;
    //RAM         RamTest    ( (UINT32*)RAMTestBase, (UINT32)RAMTestSize, (ENDIAN_TYPE)ENDIANESS, BUS_WIDTH );
    TimedEvents eventsTest;
    //UART        usartTest  ( COMTestPort, 9600, USART_PARITY_NONE, 8, USART_STOP_BITS_ONE, USART_FLOW_NONE );
    GPIO        gpioTest   ( GPIOTestPin );   
    //SPI         spiTest    ( SPIChipSelect, SPIModule, g_EEPROM_STM95x );
    Timers      timersTest ( DisplayInterval, TimerDuration );

    do
    {   
        //result = RamTest.Execute   ( STREAM__OUT );       
        result = eventsTest.Execute( STREAM__OUT );
        //result = usartTest.Execute ( STREAM__OUT );
        result = gpioTest.Execute  ( STREAM__OUT );
        //result = spiTest.Execute   ( STREAM__OUT );
        result = timersTest.Execute( STREAM__OUT );

    } while(FALSE); // run only once!

    while(TRUE);
}
 bool run(void *p)
 {
     if (p2_wire0.read())
     {
         // Turn on LED1
         LE.on(1);
     }
     else
     {
         // Turn off LED2
         LE.off(1);
     }
     return true;
 }
Exemple #18
0
static Matrix *shared_matrix()
{
    static Matrix *matrix = NULL;
    if (!matrix) {
        PanelConfiguration panelConfig;
        if (gOptions.panel_configuration_file.length()) {
            panelConfig.readConfigurationFile(gOptions.panel_configuration_file);
        }

#ifdef USE_VIRTUAL_CANVAS
        matrix = new VirtualCanvas(panelConfig.rows, panelConfig.chainedDisplays, panelConfig.parallelDisplays);
#else
        GPIO *io = new GPIO();
        if (!io->Init()) {
            cerr << "Unable to initialize GPIO. Permissions?" << endl;
            return nullptr;
        }
        matrix = new RGBMatrix(io, panelConfig.rows, panelConfig.chainedDisplays, panelConfig.parallelDisplays);
#endif
    }

    return matrix;
}
Exemple #19
0
int main(int argc, char *argv[]) {

        GPIO gpio;
        gpio.Init();
        RGBMatrix matrix(&gpio);
        Visualizer *visualizer = new Visualizer(&matrix);
        int command[]={2,0,0,0,0,0,0}; //Array with length 7 to get Information from the Webfile

        socketConnection();
        socketfunction(command); //Wait for the first command
        while(true) {

                Visualizer *visualizer = new Visualizer(&matrix);
                visualizer->setCommand(command);
                visualizer->Start(); // Start doing things.
                socketfunction(command); //change animation as needed
                visualizer->Stop();
        }

        getchar();
        close(sockfd);
        delete visualizer;

}
Exemple #20
0
v8::Handle<v8::Value> GPIO::Read(const v8::Arguments& args) {
    v8::HandleScope scope;
    GPIO* obj = ObjectWrap::Unwrap<GPIO>(args.This());
    if (!obj->opened) {
        std::string err_msg = "GPIO " + obj->pin_num + " is not opened.";
        v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg.c_str())));
        return scope.Close(v8::Undefined());
    }
    if (obj->mode == GPIO::OUT) {
        std::string err_msg = "GPIO " + obj->pin_num + " is not in the right mode";
        v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg.c_str())));
        return scope.Close(v8::Undefined());
    }
    int res = obj->read();
    std::ostringstream ss;
    ss << res;
    if (res < 0) {
        std::string err_msg = "OPERATION FAILED: Unable to change GPIO " + obj->pin_num + " value.";
        v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg.c_str())));
        return scope.Close(v8::Undefined());
    }
    obj->log("GPIO " + obj->pin_num + " value changed to " + ss.str() + ".");
    return scope.Close(v8::Integer::New(res));
}
Exemple #21
0
v8::Handle<v8::Value> GPIO::Write(const v8::Arguments& args) {
    v8::HandleScope scope;
    GPIO* obj = ObjectWrap::Unwrap<GPIO>(args.This());
    if (args.Length() < 1) {
        v8::ThrowException(v8::Exception::TypeError(v8::String::New("Wrong number of arguments")));
        return scope.Close(v8::Undefined());
    }
    if (!args[0]->IsNumber()) {
        v8::ThrowException(v8::Exception::TypeError(v8::String::New("Wrong arguments")));
        return scope.Close(v8::Undefined());
    }
    v8::Local<v8::Integer> param1 = args[0]->ToInteger();
    int value = param1->IntegerValue();
    int res = obj->write(value);
    if (res < 0) {
        std::string err_msg = "OPERATION FAILED: Unable to change GPIO " + obj->pin_num + " value.";
        v8::ThrowException(v8::Exception::Error(v8::String::New(err_msg.c_str())));
        return scope.Close(v8::Undefined());
    }
    std::ostringstream ss;
    ss << value;
    obj->log("GPIO " + obj->pin_num + " value changed to " + ss.str() + ".");
    return scope.Close(v8::Integer::New(res));
}
Exemple #22
0
void DialogRecepti::beep()
{//функция за звук при натискане на бутон
    QTime tme;
    GPIO *buzzer;
    buzzer = new GPIO(PIN31);
    buzzer->openPin();
    buzzer->setDirection(GPIO::Out);
    tme.restart();
    buzzer->setState(true);
    while(tme.elapsed()<25){qApp->processEvents();}
    buzzer->setState(false);
    buzzer->closePin();
    delete buzzer;
}
Exemple #23
0
void DialogMenu::beep()
{
 //  qApp->beep();

    QTime tme;
    GPIO *buzzer;
    buzzer = new GPIO(PIN31);
    buzzer->openPin();
    buzzer->setDirection(GPIO::Out);
    tme.restart();
    buzzer->setState(true);
    while(tme.elapsed()<25){qApp->processEvents();}
    buzzer->setState(false);
    buzzer->closePin();
    delete buzzer;
}
Exemple #24
0
int main()
{
	double record_UI_Updata=0; //UI更新时间片
	double record_UI_power=0;//电量更新
	double record_UI_time_hight=0;//时间更新
	double record_UI_YRPT_CLOCK=0;//时间更新
	double record_JoystickUpdata=0;
	double test=0;
	


	
	ledRedGPIO.SetLevel(1);
	ledGREGPIO.SetLevel(1);
	
	
	
	while(1)
	{
		Rc2Copter.DataListening();
		
		
		if(tskmgr.TimeSlice(record_UI_Updata,0.1))  //0.1秒更新一次UI
		{
				//MessageShow.setTextBox("t21",num);
			if(tskmgr.TimeSlice(record_UI_power,5))//每5秒更新一次电量值
			{
				MessageShow.setTextBox(UI_RcPower,pressure.Voltage_I(1,1,2,4.2),1);
				MessageShow.setTextBox(UI_CopterPower,Rc2Copter.RcvPower,1);
				
			}
			if(tskmgr.TimeSlice(record_UI_time_hight,1))//每秒更新一次高度和时间
			{
				MessageShow.setTextBox(UI_Hight,Rc2Copter.RcvHight,0);
				MessageShow.setTextBox(UI_AliveTime,Rc2Copter.RcvTime,0);
			}
			if(tskmgr.TimeSlice(record_UI_YRPT_CLOCK,0.5)) //没0.5秒更新一次显示
			{
				MessageShow.setTextBox(UI_YAW,Rc2Copter.RcvYaw,0);
				MessageShow.setTextBox(UI_ROOL,Rc2Copter.RcvRoll,0);
				MessageShow.setTextBox(UI_PITCH,Rc2Copter.RcvPitch,0);
				MessageShow.setTextBox(UI_THR,Rc2Copter.RcvThr,0);	
				
				if(Rc2Copter.ClockState == 1)
					MessageShow.vis(UI_FlyClock,1);//显示  为橙色
				else
					MessageShow.vis(UI_FlyClock,0);//隐藏  为蓝色
				
			}
			
			//更新摇杆状态显示
			MessageShow.outputDirection(UI_DirectionL,RC.getLeftState());
			MessageShow.outputDirection(UI_DirectionR,RC.getNightState());
			
		}
		
		if(tskmgr.TimeSlice(record_JoystickUpdata,0.1))  //0.1秒更新一次摇杆状态
		{
  				if(RC.Updata())
					{
					//遥控器状态判断  外八解锁,内八上锁
						if(RC.getLeftState() == 7 && RC.getNightState() == 9) //解
						{
								Rc2Copter.FlightLockControl(false);
						}
						else if(RC.getLeftState() == 9 && RC.getNightState() == 7)
						{
								Rc2Copter.FlightLockControl(true);
						}
						else if(RC.getLeftState() == 1 && RC.getNightState() == 3 && Rc2Copter.ClockState == 1) //外八且上锁
						{
								
						}
						else//如果处于解锁状态则发送数据
						{
								if(Rc2Copter.ClockState == 0)
								{
									//发送数据
									Rc2Copter.SendData2Copter(1000,1000,1000,1000);
								}
						}
															
					}			
		}
		if(tskmgr.TimeSlice(test,0.1))  
			com1<<pressure[5]<<"\t"<<pressure[6]<<"\t"<<pressure[8]<<"\t"<<pressure[9]<<"\n";
		
		
	}
}
int main(int argc, char *argv[]) {
	global_terminate = false;
	enabled = false;

	bool correct_luminance = true, screensaver = false, do_fork = false;
	int rows_on_display = 32, chained_displays = 1, pwm_bits = 0, brightness_in = 50, fps = 50;
	int listen_port = 3333;
	screensaver_t ss = SS_CLOCK; // FIXME commandline selectable

	std::string default_font = DEFAULT_FONT_FILE;

	int c = -1;
	while((c = getopt(argc, argv, "p:r:c:t:lsP:b:f:dF:h")) != -1)
	{
		switch(c)
		{
			case 'p':
				pwm_bits = atoi(optarg);
				break;

			case 'r':
				rows_on_display = atoi(optarg);
				break;

			case 'c':
				chained_displays = atoi(optarg);
				break;

			case 't':
				pwm_bits = atoi(optarg);
				break;

			case 'l':
				correct_luminance = !correct_luminance;
				break;

			case 's':
				screensaver = true;
				break;

			case 'P':
				listen_port = atoi(optarg);
				break;

			case 'b':
				brightness_in = atoi(optarg);
				break;

			case 'f':
				fps = atoi(optarg);
				break;

			case 'd':
				do_fork = true;
				break;

			case 'F':
				default_font = optarg;
				break;

			case 'h':
				help();
				return 0;

			default:
				help();
				error_exit(false, "option %c is not understood", c);
		}
	}

	signal(SIGINT, sigh);
	signal(SIGTERM, sigh);

	signal(SIGUSR1, toggle);

	srand(time(NULL));

	font::init_fonts();

	GPIO io;
	if (!io.Init())
		error_exit(false, "Failed to initialized GPIO sub system");

	srand(time(NULL));

	RGBMatrix m(&io, rows_on_display, chained_displays, 1);

	if (pwm_bits > 0 && !m.SetPWMBits(pwm_bits))
		error_exit(false, "Invalid range of pwm-bits");

	if (correct_luminance)
		m.set_luminance_correct(true);

	std::atomic_int brightness(brightness_in);

	double_buffer_t db;
	db.w = m.width(); // change for different panel layout
	db.h = m.height();
	int pixel_bytes = db.w * db.h * 3;
	db.data = new uint8_t[pixel_bytes];
	db.brightness = &brightness;
	db.flag = db.need_update = false;
	db.screensaver = screensaver;
	db.font_name = default_font;

	pthread_rwlock_t clients_lock;
	pthread_rwlock_init(&clients_lock, NULL);

	std::map<std::string, disp_element_t *> clients;

	ThreadedCanvasManipulator *image_gen = new UpdateMatrix(&m, &db, &clients_lock, &clients, fps, ss);

	image_gen->Start();

	if (do_fork && daemon(0, 0) == -1)
		error_exit(true, "Failed to daemon()");

	printf("Go!\n");

	main_loop(&db, &clients_lock, &clients, &brightness, &db.need_update, listen_port);

	terminate_threads(&clients_lock, &clients);

	global_terminate = true;
	image_gen->Stop();

	// Stopping threads and wait for them to join.
	delete image_gen;

	font::uninit_fonts();

	printf("END\n");

	return 0;
}
Exemple #26
0
int main(){
	u8 order=0;
	double record_updataSensor=0;
	double record_alive=0;
	double record_getwifi=0;
	bool network=false ; //网络连接标识位 
	char *ip = (char*)calloc(15, sizeof(char*) ); 
	char *WifiName = (char*)calloc(20, sizeof(char*) ); 
	char *WifiPassword = (char*)calloc(20, sizeof(char*) ); 
	
/*开机WIFI模式选择*****************************************************************/
	if(wifimemory.getWifiSum()!=0)//判断表中是否已经保存wifi信息
	{
		while( wifimemory.Load(WifiName,WifiPassword) )
		 {
			  if(wifi.ConnectNetwork_client(WifiName,WifiPassword,SERVER_IP,1111)) //每次连接历时20秒
				{network=true;   break;}
		 }
		 if(network ==false) {
			  wifi.ConnectNetwork_server(MODULE_COM,0);
			 	WIFI.ClearReceiveBuffer();
		 }
	}
  else
	{
		 wifi.ConnectNetwork_server(MODULE_COM,0);
			WIFI.ClearReceiveBuffer();
	}
	
	Led.SetLevel(1);//将指示灯熄灭(模式切换结束)
/*END*********************************************************************************/	

while(1)
	{		
		order=CMCT_Tool.GetStateOrder(WIFI);
		switch(order)
		{
			case DELAY:{}break;
	/*启动********************************************************************************************/
			case START:{//启动
				while(1){
							if(tskmgr.ClockTool(record_updataSensor,3)) //每三秒执行一次更新
							{
								co2.Updata();
								if(network)
									wifi.Send(20,CMCT_Tool.ToServerPack(CO2Number,co2.DATA_H,co2.DATA_L,0));	
								else
									wifi.Send(0,20,CMCT_Tool.ToClientPack(CO2Number,co2.DATA_H,co2.DATA_L,0));	
							}
							if(CMCT_Tool.GetStateOrder(WIFI)==DELAY)
							break;					
				}
			}break;
	/*END********************************************************************************************/			
			
	/*复位******************************************************************************************/
			case RESET:{//复位
					wifimemory.ClearAllData(); //清空所有保存信息
					*((u32 *)0xE000ED0C) = 0x05fa0004;
			}break;
	/*END******************************************************************************************/
			
	/*获取WIFI信息*********************************************************************************/		
			case GETWIFI:{//得到wifi账号密码
				record_getwifi=tskmgr.Time();
					while(1)
					{
						if(CMCT_Tool.GetWifiNameAndPassword(WifiName,WifiPassword,WIFI) )
						{
								//保存WIFI账号密码
								com<<WifiName<<"\t"<<WifiPassword<<"\n";
								break;
						}
						if(tskmgr.ClockTool(record_getwifi,30)) //超时10秒退出
						   break;
					}
			}break;
	/*END******************************************************************************************/
			
	/*模式切换*************************************************************************************/
			case MODEL:{//模式切换
					wifi.ConnectNetwork_server(MODULE_COM,0);
					WIFI.ClearReceiveBuffer();
					network=false;
			}break;
	/*END******************************************************************************************/

	/*存活确认*************************************************************************************/			
			case ALIVE:{//存活确认
				if(network)
					CMCT_Tool.SendAlive(wifi,CO2Number,1); //存活确认,数据位全为0xff
				else
					CMCT_Tool.SendAlive(wifi,CO2Number,0);
			}break;			
	/*END******************************************************************************************/		
			
	/*常态******************************************************************************************/		
			default:		
			{  
					if(tskmgr.ClockTool(record_updataSensor,3)) //每三秒执行一次更新
						 co2.Updata();//当没有命令时更新传感器
						if(tskmgr.ClockTool(record_alive,60)) //每60秒发送一次存活确认
					{
						if(network)
							CMCT_Tool.SendAlive(wifi,CO2Number,1);
						else
							CMCT_Tool.SendAlive(wifi,CO2Number,0);
					}
			}
		}		
	}
}
Exemple #27
0
int main(){
	bluetoothShutdown.on();
	en2v8.off();

	OS::run();
}
Exemple #28
0
		void update(){
			usleep(100);
	                gpio21->getval_gpio(state_button);
			if(state_button == "1"){
				        usleep(5000);
				        gpio26->setval_gpio("1");
				        gpio19->setval_gpio("0");
				        gpio13->setval_gpio("0");
				        gpio6->setval_gpio("1");
				        usleep(5000);
				        gpio26->setval_gpio("1");
				        gpio19->setval_gpio("0");
				        gpio13->setval_gpio("1");
				        gpio6->setval_gpio("0");
				        usleep(5000);
				        gpio26->setval_gpio("0");
				        gpio19->setval_gpio("1");
				        gpio13->setval_gpio("1");
				        gpio6->setval_gpio("0");
				        usleep(5000);
				        gpio26->setval_gpio("0");
				        gpio19->setval_gpio("1");
				        gpio13->setval_gpio("0");
				        gpio6->setval_gpio("1");
			}
		}
int main(int argc, char * argv[])
{
    // Parse cmd line args
    if (argc < 2)
    {
        printf("Usage: %s <gpio-pin>\n", argv[0]);
        return 1;
    }
    uint8_t gpioPin = atoi(argv[1]);

    // Setup TUI
    if (!Screen::Instance()->init())
        return 1;

    int32_t width, height;
    Screen::Instance()->size(width, height);

    // Initialize gpio
    GPIO*   gpio = NULL;
#ifdef BEAGLEBONEBLACK
    gpio = new BBBGPIO(gpioPin);
#endif

    if (gpio == NULL)
    {
        fprintf(stderr, "Error: No target device was specified when compiling this test\n");
        Screen::Instance()->destroy();
        return 1;
    }
    if (!gpio->init())
    {
        fprintf(stderr, "Error: Initializing GPIO\n");
        Screen::Instance()->destroy();
        return 1;
    }
    gpio->setMode(GPIO::OUTPUT);

    // Line content definitions
    typedef enum LINE_CONTENT_ENUM
    {
        BORDER_TOP_LINE = 0,
        TITLE_LINE,
        TITLE_SEP_LINE,
        CONTROLS_LINE,
        BORDER_BOT_LINE
    } LINE_CONTENT;

    // Print border
    Screen::Instance()->printRectangle(0, BORDER_TOP_LINE, width - 1, BORDER_BOT_LINE);

    // Print static text to screen
#ifdef BEAGLEBONEBLACK
    Screen::Instance()->printTextCenter(0, width - 1, TITLE_LINE, "embed-lib: BeagleBone Black GPIO Write Test");
#endif
    Screen::Instance()->printHLine (0, width - 1, TITLE_SEP_LINE);
    Screen::Instance()->printText(1, CONTROLS_LINE, " s - Set    r - Reset     q - Quit");

    // Main loop
    char c;
    while ((c = (Screen::Instance()->getCh())) != 'q')
    {
        switch (c)
        {
            case 's' :
                gpio->digitalWrite(1);
                break;
            case 'r' :
                gpio->digitalWrite(0);
            default:
                break;
        }
    }

    gpio->destroy();
    delete gpio;

    Screen::Instance()->destroy();
}
Exemple #30
0
int ccdbgDevice_initialize(void)
{
	return (!resetPin.isActive() || !dcPin.isActive() || !ddPin.isActive()) ? -1 : 0;
}