/* ==============================================
main task routine
============================================== */
int main(void) {
pool_memadd((uint32_t)pool, sizeof(pool));
#ifdef DEBUG
dbg.start();
#endif
// TODO: insert code here
CAdxl345 adxl;
adxl.assign(I2C0, KHZ(400));
adxl.powerOn();
CPin led(P7);
led.output(NOT_OPEN);
int x,y,z;
// Enter an endless loop
while(1){
adxl.readAccel(&x, &y, &z);
#ifdef DEBUG
if ( dbg.isDebugMode() ) {
dbg.println("X=%d, Y=%d, Z=%d\n", x, y, z);
}
#endif
led = !led;
sleep(200);
}
return 0 ;
}
/* ==============================================
main task routine
============================================== */
int main(void) {
pool_memadd((uint32_t) pool, sizeof(pool));
#ifdef DEBUG
dbg.start();
#endif
// Simple demo Code (removable)
CPin led(LED1);
// TODO: insert setup code here
CPin blinkLED(UNO_13);
blinkLED.output(NOT_OPEN);
// Enter an endless loop
while (1) {
// Simple demo Code (removable)
led = !led;
sleep(200);
// Your loop code here
blinkLED = !blinkLED;
}
return 0;
}
int main(void)
{
__disable_interrupt();
sys_init();
__delay_cycles(8000000);//Защита от коротких нажатий
P1OUT |= BIT6; //защелкиваем питание
led(1);
ADC10_Init();
AFE_Init();
rf_init();
TACCR0 = 0xFFFF;// запуск таймера
__enable_interrupt();
while (1)
{
if(rf_rx_data_ready_fg) {
onRF_MessageReceived();
rf_rx_data_ready_fg = 0;
}
if (packetDataReady){
uchar packetSize = assemblePacket();
rf_send((uchar*)&packet_buf[0], packetSize);
packetDataReady = 0;
}
if(rf_rx_data_ready_fg || packetDataReady){
// идем по циклу снова
}else{
__bis_SR_register(CPUOFF + GIE); // Уходим в спящий режим
}
}
}
//main******************************************************************
int main(void) {
DDRB =0xFF;
DIDR0=1<<ADC1D;
ADMUX=0b00000001;
ADCSRA=0b10000100;
PORTB=1<<PB2;
while(8){
int k=0;
for(k=0;k<200;k++)
{
//led(k);
led(adc());
}
}
}
static int select_card(int card_no)
{
mutex_lock(&mmc_mutex);
led(true);
last_disk_activity = current_tick;
mmc_enable_int_flash_clock(card_no == 0);
if (!card_info[card_no].initialized)
{
setup_sci1(7); /* Initial rate: 375 kbps (need <= 400 per mmc specs) */
write_transfer(dummy, 10); /* allow the card to synchronize */
while (!(SSR1 & SCI_TEND));
}
if (card_no == 0) /* internal */
and_b(~0x04, &PADRH); /* assert CS */
else /* external */
and_b(~0x02, &PADRH); /* assert CS */
if (card_info[card_no].initialized)
{
setup_sci1(card_info[card_no].bitrate_register);
return 0;
}
else
{
return initialize_card(card_no);
}
}
void test_flash_led()
{
ngac ac("ac1", 0, 5, 1);
ngresistor r("r1", 370);
ngled led("led1", 5e-3);
ngground gnd;
ngline l0(ac.p1, gnd.p1);
ngline l1(ac.p2, r.p1);
ngline l2(r.p2, led.p1);
ngline l3(led.p2, ac.p1);
schema sch;
sch.AddDevices(&ac, &r, &led, &gnd, 0);
sch.AddLines(&l0, &l1, &l2, &l3, 0);
circuit cir(&sch);
cir.Tran("2", "10m");
do
{
Sleep(200);
} while (cir.IsRunning());
getchar();
}
void test_restart()
{
ngac ac("ac1", 0, 5, 1);
ngresistor r("r1", 370);
ngled led("led1", 5e-3);
ngground gnd;
ngline l0(ac.p1, gnd.p1);
ngline l1(ac.p2, r.p1);
ngline l2(r.p2, led.p1);
ngline l3(led.p2, ac.p1);
schema sch;
sch.AddDevices(&ac, &r, &led, &gnd, 0);
sch.AddLines(&l0, &l1, &l2, &l3, 0);
circuit cir(&sch);
cir.Tran("1000");
do
{
Sleep(200);
char ch = getchar();
switch (ch)
{
case 'r':
cir.Restart();
Sleep(200);
break;
default:
break;
}
} while (cir.IsRunning());
}
/* ==============================================
main task routine
============================================== */
int main(void) {
pool_memadd((uint32_t) pool, sizeof(pool));
//#ifdef DEBUG
dbg.start();
//#endif
// Simple demo Code (removable)
CPin led(LED1);
// TODO: insert setup code here
dbg.waitToDebugMode();
Server s;
s.start("server", 180);
Client c;
c.start("client", 180);
// Enter an endless loop
while (1) {
// Simple demo Code (removable)
led = !led;
sleep(200);
// Your loop code here
}
return 0;
}
int main (void)
{
uint8_t i;
CPU_PRESCALE(0);
DDRB = 0xff;
DDRD = 0xff;
usb_init();
while(!usb_configured());
usb_buffer[0] = 0xab;
usb_buffer[1] = 0xcd;
usb_buffer[63] = 4;
led();
/* controller_mode = probe;*/
controller_mode = poll;
while(1){
switch(controller_mode){
case(probe):
_delay_ms(12);
controller_probe();
usb_rawhid_send(usb_buffer, 50);
break;
case(poll):
controller_poll();
usb_rawhid_send(usb_buffer, 50);
_delay_ms(6);
break;
}
}
return 0;
}
void MI0283QT9::begin(uint_least8_t clock_div)
{
//init pins
#if defined(RST_PIN)
pinMode(RST_PIN, OUTPUT);
RST_ENABLE();
#endif
pinMode(LED_PIN, OUTPUT);
pinMode(CS_PIN, OUTPUT);
#if defined(LCD_8BIT_SPI)
pinMode(RS_PIN, OUTPUT);
RS_HIGH();
#endif
pinMode(SCK_PIN, OUTPUT);
pinMode(MOSI_PIN, OUTPUT);
pinMode(MISO_PIN, INPUT);
LED_DISABLE();
CS_DISABLE();
#if defined(ADS7846)
pinMode(ADSCS_PIN, OUTPUT);
ADSCS_DISABLE();
#endif
#if !defined(SOFTWARE_SPI)
lcd_clock_div = clock_div;
SPI.setDataMode(SPI_MODE0);
SPI.setBitOrder(MSBFIRST);
//SPI.setClockDivider(clock_div);
SPI.begin();
#endif
//SPI speed-down
#if !defined(SOFTWARE_SPI)
# if F_CPU >= 128000000UL
SPI.setClockDivider(SPI_CLOCK_DIV64);
# elif F_CPU >= 64000000UL
SPI.setClockDivider(SPI_CLOCK_DIV32);
# elif F_CPU >= 32000000UL
SPI.setClockDivider(SPI_CLOCK_DIV16);
# elif F_CPU >= 16000000UL
SPI.setClockDivider(SPI_CLOCK_DIV8);
# else //elif F_CPU >= 8000000UL
SPI.setClockDivider(SPI_CLOCK_DIV4);
# endif
#endif
//reset display
reset();
//SPI speed-up
#if !defined(SOFTWARE_SPI)
SPI.setClockDivider(clock_div);
#endif
//enable backlight
led(50);
return;
}
Animation
ToneAnimationFactoryLoudestSmooth::createToneAnimation(unsigned int nLEDs, const ToneData& toneData)
{
Animation animation;
Frame frame(nLEDs);
for (unsigned int i = 0; i < nLEDs; ++i)
{
double r = 0.0;
double g = 0.0;
double b = 0.0;
for (const auto& toneAmplitude : toneData.currentTones)
{
if (toneAmplitude.first == Tone::C)
{
r += toneAmplitude.second;
}
else if (toneAmplitude.first == Tone::D)
{
r += toneAmplitude.second/2.0;
}
else if (toneAmplitude.first == Tone::E)
{
g += toneAmplitude.second;
}
else if (toneAmplitude.first == Tone::F)
{
g += toneAmplitude.second/2.0;
}
else if (toneAmplitude.first == Tone::G)
{
b += toneAmplitude.second;
}
else if (toneAmplitude.first == Tone::A)
{
b += toneAmplitude.second/2.0;
}
else if (toneAmplitude.first == Tone::B)
{
r += toneAmplitude.second;
}
}
double norm = std::sqrt(r*r+g*g+b*b);
int rNorm = static_cast<int>(r/norm*255);
int gNorm = static_cast<int>(g/norm*255);
int bNorm = static_cast<int>(b/norm*255);
Color color(rNorm, gNorm, bNorm);
LED led(i, color);
frame.addLED(led);
}
animation.addFrame(frame);
return animation;
}
void test_switch_by_csw()
{
ngdc dc("dc1", 5);
ngspst spst("spst", ngspst::on);
ngresistor r("1", 5);
ngled led("led");
ngground gnd;
ngline l1(dc.pos, spst.p1);
ngline l2(spst.p2, r.p1);
ngline l3(r.p2, led.pos);
ngline l4(led.neg, dc.neg);
ngline l0(dc.neg, gnd.ground);
schema sch;
sch.AddDevices(&dc, &spst, &r, &gnd, &led, 0);
sch.AddLines(&l1, &l2, &l3, &l0, &l4, 0);
circuit cir(&sch);
#if 0//not work
// tran with spst disconnected
cir.Tran("10", "1m");
do
{
Sleep(100);
} while (cir.IsRunning());
//cir.Stop();
// tran with spst connected, however it's still disconnected
string sw = spst.switchover();
cir.Do(sw);
cir.Tran("10", "1m");
do
{
Sleep(100);
} while (cir.IsRunning());
#endif
// run with event input to switch spst
cir.Tran("1t", "1m", 0);
do
{
Sleep(200);
char ch = getchar();
switch (ch)
{
case 'a':
cir.SwitchOver(&spst);
Sleep(200);
break;
case 'q':
cir.Halt();
default:
break;
};
} while (cir.IsRunning());
}
void prvL_buttonTask() //
{
char state = 1; // ON
led(state, POS);
while(1)
{
xSemaphoreTake(l_button_sem, portMAX_DELAY); // wait for a button interrupt
vTaskDelay(DELAY); // avoid bounces
xSemaphoreTake(l_button_sem, 0); // cancel bounce period interruptions
if ( !(GPIOC->IDR & GPIO_IDR_IDR13) )
{
led(state, POS);
state = state? 0 : 1;
}
}
}
//==================================================
void SetSingleLED (unsigned id, bool state)
//==================================================
{
EpuckLEDs led(SP);
led.SetRingLED(id,state);
led.ClearInternal();
}
//==================================================
void SetRingLED (bool ringLED[RING_LEDS_NUM])
//==================================================
{
EpuckLEDs led(SP);
led.SetRingLED(ringLED);
led.ClearInternal();
}
void led(int * a,int b)
{
P1 = a[b++];
sleep();
if (b < 8) led(a,b);
P1 = a[--b];
sleep();
}
/******************************************
****************题目二*********************
*******************************************/
void mode2()
{
keyt();
if(active==0&&angle_fuse>angle_set-5)
active=1;
else if(active==1)
led (LED0,LED_ON);
}
void main()
{
for(;;)
{
led();
}
}
__irq void swi_handler(void)
#endif
{
#if OPTION_ENABLE_ASSERT
g_barrier2 = 0;
while (g_barrier2 == 0)
{
led(1);
delay(700000);
led(0);
delay(700000);
}
#endif
}
int main( void )
{
WDTCTL = WDTPW + WDTHOLD; // Disable watchdog timer
P1DIR = 0b01000111; // IN:UltraEcho(P1.6) Colour1(P1.1),Colour2(P1.2),Colour3(P1.3) OUT:UltraTrig(P1.7)
P2DIR = 0b00110110; // OUT:MotorOppCap(P2.1 and P2.2), MotorCap(P2.3 and P2.4)
// Configure the Basic Clock Module
DCOCTL = CALDCO_1MHZ;
BCSCTL1 = CALBC1_1MHZ;
// Main loop repeats forever
while(1)
{
if (detected() == 1) // If ultrasonic detects within 77cm
{
led(1); // Turn on the LED
forward(); // Drive both motors forward
}
else // If ultrasonic doesn't detect within 74cm
{
led(0); // Turn off the LED
turn_left(); // Begin Spinning to the left.
}
if (colourFor() == 1)
{
backward(); // Drive both motors forward.
}
if (colourBkL() == 1)
{
turn_right(); // Spin the robot to the right.
}
if (colourBkR() == 1)
{
turn_left(); // Spin the robot to the left.
}
__delay_cycles(50000); // Delay for 50ms to allow echo pulse to die down
}
}
void main(void)
{
unsigned char a;
a=0;
for(;;)
{
P0=led(a);
delay(ALOOPS);
P0=led(0);
delay(30000);
P0=led(3);
delay(15000);
P0=led(12);
delay(7500);
P0=led(48);
delay(3500);
P0=led(192);
delay(1750);
P0=led(0);
delay(800);
a++;
}
}
void StartDefaultTask(void const * argument) {
Pin led(LED_PIN, Pin::Config().setMode(Pin::MODE_OUTPUT));
int count = 0;
printf("Hello, world!\n");
while (1) {
led.write(count++ & 1);
osDelay(250);
}
}
int main(int argc, char **argv) {
int ret;
ret = usart(argc-1,argv); //(+sizeof(char *));
if(ret < 0) return ret;
ret = led();
if(ret < 0) return ret;
ret = gpio();
return ret;
}
static void deselect_card(void)
{
while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
or_b(0x06, &PADRH); /* deassert CS (both cards) */
led(false);
mutex_unlock(&mmc_mutex);
last_disk_activity = current_tick;
}
void
Frame::setAllLedsOff()
{
for (int i = 1; i <= m_nLEDs; ++i)
{
LED led(i, Color());
m_leds[i] = led;
}
}
void
main_sh (void)
{
led(0x40);
uart_set_baudrate ();
led(0x042);
putstr ("CPU tests passed\n");
led(0x043);
putstr ("DDR Init\n");
led(0x042);
ddr_init ();
putstr ("GDB Stub for HS-2J0 SH2 ROM\n");
putstr (version_string);
led(0x50);
}
int main() {
DDRA = 0x00; PORTA = 0xFF;
DDRB = 0xFF; PORTB = 0x00;
DDRC = 0xFF; PORTC = 0x00;
LED_State = start; // Initial state
while(1) {
led();
}
}
static int handle_usb_events(void)
{
#if (CONFIG_STORAGE & STORAGE_MMC)
int next_update=0;
#endif /* STORAGE_MMC */
/* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
while(1)
{
int button;
#ifdef USB_ENABLE_HID
if (usb_hid)
{
button = get_hid_usb_action();
/* On mode change, we need to refresh the screen */
if (button == ACTION_USB_HID_MODE_SWITCH_NEXT ||
button == ACTION_USB_HID_MODE_SWITCH_PREV)
{
break;
}
}
else
#endif
{
button = button_get_w_tmo(HZ/2);
/* hid emits the event in get_action */
send_event(GUI_EVENT_ACTIONUPDATE, NULL);
}
switch(button)
{
case SYS_USB_DISCONNECTED:
usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
return 1;
case SYS_CHARGER_DISCONNECTED:
/*reset rockbox battery runtime*/
global_status.runtime = 0;
break;
case SYS_TIMEOUT:
break;
}
#if (CONFIG_STORAGE & STORAGE_MMC) /* USB-MMC bridge can report activity */
if(TIME_AFTER(current_tick,next_update))
{
if(usb_inserted()) {
led(mmc_usb_active(HZ));
}
next_update=current_tick+HZ/2;
}
#endif /* STORAGE_MMC */
}
return 0;
}
virtual void run() {
dbg.println("T enters the run-loop:");
A a;
CPin led(LED2);
while (isAlive()) {
led = !led;
sleep(200);
}
dbg.println("T exits the run-loop:");
}
void Indicator::playsound(int melody[], int duration[], int length){
for(int i = 0, l = true; i < length; i++, l = !l){
led(l, !l);
int nduration = 1000/(duration[i]);
int pause = nduration * 1.30;
tone(_SPEAKER, melody[i], nduration);
_delay_ms(pause);
noTone(_SPEAKER);
}
led(false, false);
}
