打算弄一个程序编码转换器，功能是在网站上显示出带有缩进和着色的效果
先手工试试红色
红色<font color="#00FF00">绿色<font color="#0000FF">蓝色</font></font>
好啦。
程序：
<font color="#0000FF">void main()
{
int test = 34;
while(1)
{
//应该是绿色的
}
}
</font>
//电子琴程序,执行时依次用128种乐器演奏一首乐曲
//注意,这个程序运行后没有界面,只能用任务管理器结束进程
u.cpu = u.cputype.pc80x86;
u.entry = engine;
//加载windows内核类
import syslib.windows.kernel32;
//加载MIDI接口类
import syslib.windows_pack.midi;
//=======================================
//引擎函数, 驱动整个系统运行
public void engine()
{
//打开MIDI设备
midi.open();
//用128种音色播放(注意是每隔8个乐器选择一次,这样相邻两次播放曲子的音色明显不同
for( uint8 offset = 0; offset < 8; ++offset ) {
for( uint8 ii = offset; ii < 128; ii += 8 ) {
//设置当前音色
midi.set_timbre( 0, ii );
//用当前音色播放一遍曲子,曲子一共有65个音符
for( uint8 i = 0; i < 65; ++i ) {
uint8 d = song[i];
uint16 t = d >> 4;
uint8 scale = d & 0x0f;
midi.play( 0, 60 + seg[scale], 90 );
kernel32.Sleep( t * 200 );
midi.stop( 0, 60 + seg[scale] );
}
kernel32.Sleep( 300 );
}
}
kernel32.ExitProcess( 0 );
}
//各个音的频率, 3-4 和 7-1 之间差一个半音,其他的相差一个全音
[]u.code uint8 seg = {
// 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7
0, 2, 4, 5, 7, 9,11,12,14,16,17,19,21,23,24,26,28,29,31,33,35
};
//敖包相会的曲子,每个字节的高位表示时值;低位表示音阶,0~f依次对应 67-1234567-1234567
[]u.code uint8 song = {
0x20,0x48,0x2a,0x2a,0x18,0x17,0x45,0x25,0x47,0x28,0x37,0x18,0x4a,0x88,
0x20,0x48,0x2a,0x2a,0x18,0x17,0x45,0x25,0x47,0x28,0x27,0x28,0x2a,0x18,0x17,0x85,
0x25,0x17,0x28,0x2a,0x25,0x24,0x23,0x20,0x44,0x24,0x23,0x34,0x15,0x28,0x27,0x85,
0x25,0x17,0x28,0x18,0x1a,0x25,0x24,0x23,0x20,0x34,0x17,0x25,0x25,0x23,0x13,0x10,0x24,0x23,0x80
};
=======================================================================================
弄好了，11年电子设计竞赛B题（自由摆）的程序，嘿嘿
=======================================================================================
//选择芯片类型
u.cpu = u.cputype.mega32;
//配置程序入口
u.entry = controller.engine;
//加载芯片类
import syslib.avr.mega32.chip;
//************************************************************************************
//系统任务类,这里的类集合通过操作系统调用实现功能
//=====================================================
//步进电机类
//应用者需要按照固定的间隔 t 调用 run() 函数,通过 angle 读取和控制电机旋转角度
//间隔 t 决定步进电机的旋转速度
unit motor
{
//////////////////////////////////////////////////
//这个函数为临时加入函数,功能是控制步进电机正向旋转180度
bool is_stoped;
bool is_test;
uint8 index;
public void rol_half_circle()
{
if( is_test ) {
return;
}
is_test = true;
index = 200;
is_stoped = false;
}
//////////////////////////////////////////////////
//初始化
public void init()
{
DDR = 0xff;
PORT = 0x00;
current_angle = 0s;
angle = 0s;
is_OK = true;
is_slow = false;
slow_v = 0;
step = 0;
is_test = false;
index = 0;
}
//运行一步,判断当前角度和目标角度的偏差并控制步进电机相应运动
public void run()
{
is_OK = false;
if( is_slow ) {
++slow_v;
if( slow_v == 15 ) {
slow_v = 0;
}
else {
return;
}
}
if( angle >= 200s ) {
angle -= 400s;
}
if( angle <= -201s ) {
angle += 400s;
}
//如果当前角度等于目标角度,直接返回
if( current_angle == angle && !is_test ) {
is_OK = true;
return;
}
bool to_big;
bool is_higher = angle > current_angle;
//根据当前角度和目标角度的关系判断电机的运动方向
if( is_higher ) {
if( angle - current_angle < 200s ) {
to_big = true;
}
else {
to_big = false;
}
}
else {
if( angle - current_angle > -200s ) {
to_big = false;
}
else {
to_big = true;
}
}
if( is_test ) {
--index;
if( index == 0 ) {
is_test = false;
}
to_big = true;
angle = current_angle + 1s;
if( index % 3 == 0 ) {
if( !is_stoped ) {
++index;
is_stoped = true;
return;
}
is_stoped = false;
}
}
//调整电机轴到目标角度
if( to_big ) {
++current_angle;
if( current_angle >= 200s ) {
current_angle = -200s;
}
if( step == 0 ) {
step = 7;
}
else {
--step;
}
}
else {
--current_angle;
if( current_angle <= -201s ) {
current_angle = 199s;
}
if( step == 7 ) {
step = 0;
}
else {
++step;
}
}
//输出一个脉冲
PORT = step_seg_8[step];
}
uint8 slow_v;
public bool is_slow;
public bool is_OK;
public sint16 angle;
public sint16 current_angle;
uint8 step;
//步进电机单步驱动模式表(调试用,已无效)
[4]u.code uint8 step_seg_4 = {
0b0000_0001,
0b0000_0010,
0b0000_0100,
0b0000_1000
};
//步进电机半步驱动模式表
[8]u.code uint8 step_seg_8 = {
0b0000_0001,
0b0000_0011,
0b0000_0010,
0b0000_0110,
0b0000_0100,
0b0000_1100,
0b0000_1000,
0b0000_1001
};
link uint8 PORT = u.user.chip.PORTB;
link uint8 DDR = u.user.chip.DDRB;
}
//=====================================================
//显示屏类
unit screen
{
//显示字符代号
public uint8 N_0 = [u.const]0x00; //0
public uint8 N_1 = [u.const]0x01; //1
public uint8 N_2 = [u.const]0x02; //2
public uint8 N_3 = [u.const]0x03; //3
public uint8 N_4 = [u.const]0x04; //4
public uint8 N_5 = [u.const]0x05; //5
public uint8 N_6 = [u.const]0x06; //6
public uint8 N_7 = [u.const]0x07; //7
public uint8 N_8 = [u.const]0x08; //8
public uint8 N_9 = [u.const]0x09; //9
public uint8 N_A = [u.const]0x0a; //a
public uint8 N_B = [u.const]0x0b; //b
public uint8 N_C = [u.const]0x0c; //c
public uint8 N_D = [u.const]0x0d; //d
public uint8 N_E = [u.const]0x0e; //e
public uint8 N_F = [u.const]0x0f; //f
public uint8 NULL = [u.const]0x10; //无显示
public uint8 LINE = [u.const]0x11; //显示中间的横线
//初始化
public void init()
{
PORT_ddr = 0xff;
PORT = 0x00;
SELECT_ddr = SELECT_ddr | 0xf0;
SELECT = SELECT & 0xf0;
select = 0x10;
index = 0;
//清空屏幕
clear();
}
//清空屏幕显示
public void clear()
{
buffer[0] = NULL;
buffer[1] = NULL;
buffer[2] = NULL;
buffer[3] = NULL;
}
//显示等待信息
public void show_wait()
{
buffer[0] = LINE;
buffer[1] = LINE;
buffer[2] = LINE;
buffer[3] = LINE;
}
//设置需要显示的数值,无符号十进制数
public void show_u_number( uint16 data )
{
uint16 m;
buffer[0] = NULL;
buffer[1] = NULL;
buffer[2] = NULL;
buffer[3] = NULL;
//转换个位数
m = data % 10;
buffer[3] = (uint8)m;
//转换十位数
data /= 10;
if( data == 0 ) {
return;
}
m = data % 10;
buffer[2] = (uint8)m;
//转换百位数
data /= 10;
if( data == 0 ) {
return;
}
m = data % 10;
buffer[1] = (uint8)m;
//转换千位数
data /= 10;
if( data == 0 ) {
return;
}
m = data % 10;
buffer[0] = (uint8)m;
}
//设置需要显示的数值,有符号十进制数
public void show_s_number( sint16 data )
{
uint16 m;
buffer[0] = NULL;
buffer[1] = NULL;
buffer[2] = NULL;
buffer[3] = NULL;
uint16 d = (uint)data;
bool is_neg = data < 0s;
if( is_neg ) {
d = ~d + 1;
}
//转换个位数
m = d % 10;
buffer[3] = (uint8)m;
//转换十位数
d /= 10;
if( d == 0 ) {
if( is_neg ) {
buffer[2] = LINE;
}
return;
}
m = d % 10;
buffer[2] = (uint8)m;
//转换百位数
d /= 10;
if( d == 0 ) {
if( is_neg ) {
buffer[1] = LINE;
}
return;
}
m = d % 10;
buffer[1] = (uint8)m;
if( is_neg ) {
buffer[0] = LINE;
}
}
//显示进程, 需要每隔至多10ms调用一次,否则屏幕闪烁
public void run()
{
PORT = 0xff;
SELECT = SELECT & 0x0f | select;
PORT = seg[buffer[index]];
select <<= 1;
++index;
if( index == 4 ) {
select = 0x10;
index = 0;
}
}
//显示缓冲区
public [4]uint8 buffer;
//显示段码, 数码管字形表
[18]u.code uint8 seg = {
0b1100_0000, 0b1111_1001, 0b1010_0100, 0b1011_0000, //0,1,2,3
0b1001_1001, 0b1001_0010, 0b1000_0010, 0b1111_1000, //4,5,6,7
0b1000_0000, 0b1001_0000, 0b1000_1000, 0b1000_0011, //8,9,A,B
0b1100_0110, 0b1010_0001, 0b1000_0110, 0b1000_1110, //C.D,E,F
0b1111_1111, //无字符 NULL
0b1011_1111 //横线 LINE
};
//当前选中的位
uint8 select;
//当前选中的序号
uint8 index;
//段码端口
link uint8 PORT = u.user.chip.PORTC;
link uint8 PORT_ddr = u.user.chip.DDRC;
//位选信号线,位于端口的高4位
link uint8 SELECT = u.user.chip.PORTA;
link bit SELECT_ddr = u.user.chip.DDRA;
}
//=====================================================
//声音提示类
unit sound
{
//声音类型: 选择下一个
public uint8 NEXT = [u.const]0;
//声音类型: 确定
public uint8 OK = [u.const]1;
//声音类型: 退出
public uint8 EXIT = [u.const]1;
//声音类型: 辅助功能
public uint8 FUNC = [u.const]2;
//声音类型: 开始放手
public uint8 START = [u.const]0;
//初始化
public void init()
{
OUT_ddr = high;
OUT = low;
is_output = false;
times = 0;
sound_type = 0;
}
//开始播放声音,参数为需要播放的声音种类
public void play( uint8 types )
{
if( is_output ) {
return;
}
is_output = true;
sound_type = types;
switch( types ) {
case 0: times = type0_max_time; break;
case 1: times = type1_max_time; break;
case 2: times = type2_max_time; break;
}
}
//声音控制进程
public void run()
{
if( !is_output ) {
return;
}
--times;
switch( sound_type ) {
case 0: sound_type0(); return;
case 1: sound_type1(); return;
case 2: sound_type2(); return;
}
}
//声音类型0
uint8 type0_max_time = [u.const]100;
void sound_type0()
{
if( times == 0 ) {
OUT = low;
is_output = false;
return;
}
if( times < 30 ) {
OUT = ~OUT;
return;
}
if( times < 70 ) {
return;
}
if( times < 100 ) {
OUT = ~OUT;
return;
}
}
//声音类型1
uint8 type1_max_time = [u.const]240;
void sound_type1()
{
if( times == 0 ) {
OUT = low;
is_output = false;
return;
}
if( times < 40 ) {
OUT = ~OUT;
return;
}
if( times < 100 ) {
return;
}
if( times < 140 ) {
OUT = ~OUT;
return;
}
if( times < 200 ) {
return;
}
if( times < 240 ) {
OUT = ~OUT;
return;
}
}
//声音类型2
uint8 type2_max_time = [u.const]10;
void sound_type2()
{
if( times == 0 ) {
OUT = low;
is_output = false;
return;
}
if( times < 10 ) {
OUT = ~OUT;
return;
}
}
//是否处于播放声音中
bool is_output;
//当前播放步数
uint8 times;
//当前声音类型
uint8 sound_type;
link bit OUT = u.user.chip.PORTA.3;
link bit OUT_ddr = u.user.chip.DDRA.3;
}
//=====================================================
//按键类
unit key
{
//初始化
public void init()
{
KEY1_ddr = low;
KEY1_port = high;
KEY2_ddr = low;
KEY2_port = high;
key1 = false;
key2 = false;
key1_used = false;
key2_used = false;
}
//按键扫描进程
public void run()
{
key1 = KEY1_pin == low;
key2 = KEY2_pin == low;
if( !key1 ) {
key1_used = false;
}
if( !key2 ) {
key2_used = false;
}
}
//模式设定键
public link bool MODE_press() {} = key1_press;
public link bool MODE_enable() {} = key1_enable;
//开始/辅助功能键
public link bool FUNC_press() {} = key2_press;
public link bool FUNC_enable() {} = key2_enable;
//判断按键1是否按下
bool key1_press()
{
return key1;
}
//判断按键1是否有效(刚刚按下)
bool key1_enable()
{
if( key1 ) {
if( !key1_used ) {
key1_used = true;
return true;
}
}
return false;
}
//判断按键2是否按下
bool key2_press()
{
return key2;
}
//判断按键2是否有效(刚刚按下)
bool key2_enable()
{
if( key2 ) {
if( !key2_used ) {
key2_used = true;
return true;
}
}
return false;
}
bool key1_used;
bool key2_used;
bool key1;
bool key2;
link bit KEY1_pin = u.user.chip.PIND.6;
link bit KEY1_ddr = u.user.chip.DDRD.6;
link bit KEY1_port = u.user.chip.PORTD.6;
link bit KEY2_pin = u.user.chip.PIND.7;
link bit KEY2_ddr = u.user.chip.DDRD.7;
link bit KEY2_port = u.user.chip.PORTD.7;
}
//=====================================================
//加载并配置灯光提示类
unit out_led
{
//初始化
public void init()
{
LED_ddr = high;
is_flash = false;
times = 0;
next_status = high;
}
//LED控制进程
public void run()
{
if( !is_flash ) {
return;
}
if( next_status == high ) {
if( times == 0 ) {
is_flash = false;
return;
}
--times;
}
LED_port = next_status;
next_status = ~next_status;
}
//闪烁
public void flash( uint8 n )
{
if( is_flash ) {
return;
}
is_flash = true;
times = n;
}
bit next_status;
bool is_flash;
uint8 times;
link bit LED_ddr = u.user.chip.DDRA.2;
link bit LED_port = u.user.chip.PORTA.2;
}
//=====================================================
//微型操作系统(时间片轮转运行多任务)
//任务执行频率为1000Hz(每隔1ms扫描所有任务)
//通过 timer_init() 修改时间
os.screen = screen;
os.motor = motor;
os.sound = sound;
os.key = key;
os.out_led = out_led;
unit os
{
public link unit screen {}
public link unit motor {}
public link unit sound {}
public link unit key {}
public link unit out_led {}
//操作系统初始化
public void init()
{
//OS初始化(与任务无关项)
timer_init();
//任务初始化
task_init();
}
//开始操作系统运行(定时器后台运行)
public void start()
{
//打开中断,进入系统工作状态
#asm "sei"
}
//定时器初始化
//晶振 12MHz, 分频比为64, 计数脉冲频率为 187500Hz
//计数值为 0 * 256 + 188 = 188
//中断频率为 187500 / 188 = 1000Hz
void timer_init()
{
//工作模式设置
chip.TCCR1A = 0;
chip.TCCR1B = 0b0000_1011;
//定时间隔设置
chip.OCR1AH = 0;
chip.OCR1AL = 188;
//清中断
chip.TIMSK |= 0b0001_0000;
}
//任务初始化
void task_init()
{
screen_tick = 0;
motor_tick = 0;
sound_tick = 0;
key_tick = 0;
out_led_tick = 0;
}
//中断服务函数
interrupt [chip.interrupt_m.timer1_compA] void timer1_compA()
{
#asm "cli"
//运行屏幕显示进程
++screen_tick;
if( screen_tick == max_screen_tick ) {
screen_tick = 0;
screen.run();
}
//运行电机控制进程
++motor_tick;
if( motor_tick == max_motor_tick ) {
motor_tick = 0;
motor.run();
}
//运行声音控制进程
++sound_tick;
if( sound_tick == max_sound_tick ) {
sound_tick = 0;
sound.run();
}
//运行按键扫描进程
++key_tick;
if( key_tick == max_key_tick ) {
key_tick = 0;
key.run();
}
//运行指示灯控制进程
++out_led_tick;
if( out_led_tick == max_out_led_tick ) {
out_led_tick = 0;
out_led.run();
}
}
//屏幕显示进程参数
uint8 screen_tick;
uint8 max_screen_tick = [u.const]5;
//电机控制进程参数
uint8 motor_tick;
uint8 max_motor_tick = [u.const]3;
//声音控制进程参数
uint8 sound_tick;
uint8 max_sound_tick = [u.const]1;
//按键扫描进程参数
uint8 key_tick;
uint8 max_key_tick = [u.const]50;
//指示灯控制进程参数
uint8 out_led_tick;
uint8 max_out_led_tick = [u.const]120;
link unit chip {} = u.user.chip;
}
//************************************************************************************
//以下为非进程函数,直接进行调用,有些函数的执行时间可能很长
//加载软件定时器类
import syslib.software.time.avr_12mhz.time;
//=====================================================
//加载并配置指示灯类
unit led_pack
{
public link unit user {} = led;
unit config
{
public link bit LED_ddr = u.user.chip.DDRA.1;
public link bit LED_port = u.user.chip.PORTA.1;
}
led.config = config;
led.time = u.user.time;
import syslib.hardware.led.avr_single.led;
}
//=====================================================
//激光器类
unit laser
{
//初始化
public void init()
{
OUT_ddr = high;
OUT = low;
}
//打开激光器
public void open()
{
OUT = high;
}
//关闭激光器
public void close()
{
OUT = low;
}
link bit OUT = u.user.chip.PORTD.0;
link bit OUT_ddr = u.user.chip.DDRD.0;
}
//=====================================================
//自由摆 角度转换类
unit pendulum
{
//初始化
public link void init() {} = AD.init;
//获取单摆角度
public sint16 read_angle()
{
uint16 data = AD.convert( 0 );
return (sint)( data - 512 ) * 40s / 135s;
//忽略下列运算
data >>= 2;
return (sint)standard_angle[data.0[uint8]];
}
///////////////////////////////////////////////
//注意:以下表格仅用于调试,已无效
//电位器角度范围: 277°
[256]u.code uint8 standard_angle = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0,128,129,130,131,133,134,135,136,137,139,140,
141,142,143,145,146,147,148,149,151,152,153,154,156,157,158,159,
160,162,163,164,165,166,168,169,170,171,172,174,175,176,177,178,
180,181,182,183,184,186,187,188,189,190,192,193,194,195,196,198,
199,200,201,202,204,205,206,207,208,210,211,212,213,214,216,217,
218,219,220,222,223,224,225,226,228,229,230,231,232,234,235,236,
237,238,240,241,242,243,244,246,247,248,249,250,252,253,254,255,
0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 18,
19, 20, 21, 22, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 36, 37,
38, 39, 40, 42, 43, 44, 45, 46, 48, 49, 50, 51, 52, 54, 55, 56,
57, 58, 60, 61, 62, 63, 64, 66, 67, 68, 69, 70, 72, 73, 74, 75,
76, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 90, 91, 92, 93, 94,
96, 97, 98, 99,100,102,103,104,105,107,108,109,110,111,113,114,
115,116,117,119,120,121,122,123,125,126,127, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
//==============================================
//AD转换元件
unit AD
{
//初始化
public void init()
{
chip.DDRA.0 = low;
chip.PORTA.0 = low;
chip.ADCSRA = 0b1000_0111;//128分频
}
//读取某个通道的AD数值
public uint16 convert( uint8 channel )
{
chip.ADMUX = 0b0100_0000 + channel;
chip.ADCSRA.6 = high;
while( chip.ADCSRA.4 == low ) {}
chip.ADCSRA.4 = low;
uint16 data;
data.0[uint8] = chip.ADCL;
data.8[uint8] = chip.ADCH;
return data;
}
link unit chip {} = u.user.chip;
}
}
//************************************************************************************
//主控制类集合,在此对所有设备进行控制
//=====================================================
//主控制元件
controller.led = led_pack.user;
controller.time = time;
controller.motor = motor;
controller.key = key;
controller.screen = screen;
controller.sound = sound;
controller.out_led = out_led;
controller.pendulum = pendulum;
controller.laser = laser;
controller.os = os;
controller.function_list = function_list;
unit controller
{
public link unit led {}
public link unit time {}
public link unit motor {}
public link unit key {}
public link unit screen {}
public link unit sound {}
public link unit out_led {}
public link unit pendulum {}
public link unit laser {}
public link unit function_list {}
public link unit os {}
//引擎函数
public void engine()
{
//----------------------------------------
//底层驱动类
//指示灯初始化
led.init();
led.flash( 3 );
time.delay_10ms( 50 );
//单摆角度转换器初始化
pendulum.init();
//激光器初始化
laser.init();
//----------------------------------------
//系统进程类
//灯光提示初始化
out_led.init();
//声音提示初始化
sound.init();
//按键初始化
key.init();
//显示屏初始化
screen.init();
//步进电机初始化
motor.init();
//操作系统初始化
os.init();
//开始运行操作系统(在后台运行)
os.start();
//----------------------------------------
//运行用户界面
UI();
}
//用户界面初始化
void UI_init()
{
out_led.flash( 5 );
sound.play( sound.OK );
current_item_index = 0;
UI_refresh();
}
//刷新用户界面显示
void UI_refresh()
{
uint8 i = 0;
loop( 4 ) {
screen.buffer[i] = item_name_list[current_item_index][i];
++i;
}
}
//用户界面
void UI()
{
//用户界面初始化
UI_init();
//无限循环,运行用户界面
forever {
//如果按下模式选择键,选择下一个模式
if( key.MODE_enable() ) {
sound.play( sound.NEXT );
out_led.flash( 1 );
++current_item_index;
if( current_item_index == item_number ) {
current_item_index = 0;
}
}
//如果按下功能键,进入当前模式
if( key.FUNC_enable() ) {
sound.play( sound.OK );
out_led.flash( 3 );
//根据当前选中菜单项执行相应功能
switch( current_item_index ) {
case 0: function_list.base_function1();
break;
case 1: function_list.base_function2();
break;
case 2: function_list.base_function3();
break;
case 3: function_list.extend_function1();
break;
case 4: function_list.extend_function2();
break;
case 5: function_list.my_function1();
break;
default: //流程不会执行到这里
break;
}
current_item_index = 0;
}
//刷新用户界面
UI_refresh();
}
}
//当前选中菜单项
uint8 current_item_index;
//菜单项数目
uint8 item_number = [u.const]6;
//用户界面菜单项元素显示
[item_number][4]u.code uint8 item_name_list = {
1, 0x11, 0x0b, 1,
2, 0x11, 0x0b, 2,
3, 0x11, 0x0b, 3,
4, 0x11, 0x0e, 1,
5, 0x11, 0x0e, 2,
6, 0x11, 0x0a, 1
};
}
//=====================================================
//用户功能类
function_list.motor = motor;
function_list.key = key;
function_list.screen = screen;
function_list.sound = sound;
function_list.out_led = out_led;
function_list.pendulum = pendulum;
function_list.laser = laser;
function_list.time = time;
unit function_list
{
public link unit motor {}
public link unit key {}
public link unit screen {}
public link unit sound {}
public link unit out_led {}
public link unit pendulum {}
public link unit laser {}
public link unit time {}
//以下设计了很多功能程序,按照电子大赛B题的题目要求只需展示其中的5个功能
//通过虚拟函数链接到对应的功能函数
public link void base_function1() {} = 摆动一个周期平板自动旋转一周;
public link void base_function2() {} = 托住一枚硬币;
public link void base_function3() {} = 托住八枚硬币;
public link void extend_function1() {} = 激光笔静止定位;
public link void extend_function2() {} = 激光笔自动跟踪;
public link void my_function1() {} = 自动保持平板水平;
//空函数
public void NULL_function() {}
public void 摆动一个周期平板自动旋转一周()
{
sint16 buffer0 = 0s;
sint16 buffer1 = 0s;
sint16 buffer2 = 0s;
sint16 current_angle = 0s;
uint8 screen_tick = 0;
forever {
//按下模式键则退出当前功能, 返回模式选择用户界面
if( key.MODE_enable() ) {
sound.play( sound.EXIT );
return;
}
//读取角度并计算平均数
buffer0 = buffer1;
buffer1 = buffer2;
buffer2 = current_angle;
current_angle = pendulum.read_angle();
current_angle += buffer2 + buffer1 + buffer0;
current_angle /= 4s;
if( current_angle == 0s ) {
motor.rol_half_circle();
}
//显示进程
++screen_tick;
if( screen_tick == 10 ) {
screen_tick = 0;
screen.show_s_number( current_angle );
}
}
}
public void 托住一枚硬币()
{
sint16 buffer0 = 0s;
sint16 buffer1 = 0s;
sint16 buffer2 = 0s;
sint16 current_angle = 0s;
uint8 screen_tick = 0;
//等待开始
while( !key.FUNC_enable() ) {
//读取当前角度并进行滤波
buffer0 = buffer1;
buffer1 = buffer2;
buffer2 = current_angle;
current_angle = pendulum.read_angle();
current_angle += buffer2 + buffer1 + buffer0;
current_angle /= 4s;
//保持平板水平
motor.angle = -current_angle;
//显示进程
++screen_tick;
if( screen_tick == 10 ) {
screen_tick = 0;
screen.show_s_number( current_angle );
}
}
sound.play( sound.START );
//显示等待
screen.show_wait();
//用户等待
time.delay_10ms( 250 );
//指示操作者开始放手
out_led.flash( 3 );
sound.play( sound.START );
//等待操作者的反应时间
time.delay_10ms( 30 );
bool is_ok = false;
forever {
//按下模式键则退出当前功能, 返回模式选择用户界面
if( key.MODE_enable() ) {
sound.play( sound.EXIT );
return;
}
//读取角度
buffer0 = buffer1;
buffer1 = buffer2;
buffer2 = current_angle;
current_angle = pendulum.read_angle();
current_angle += buffer2 + buffer1 + buffer0;
current_angle /= 4s;
if( !is_ok ) {
motor.angle = -current_angle / 3s;
if( current_angle > 0s ) {
motor.angle = 0s;
is_ok = true;
}
}
//显示进程
++screen_tick;
if( screen_tick == 10 ) {
screen_tick = 0;
screen.show_s_number( current_angle );
}
}
}
public void 托住八枚硬币()
{
//哎 没实现...
//用前一个函数实现这个功能,效果不太好.
//没时间了,就这样吧
托住一枚硬币();
}
public void 激光笔静止定位()
{
sint16 buffer0 = 0s;
sint16 buffer1 = 0s;
sint16 buffer2 = 0s;
sint16 current_angle = 0s;
uint8 screen_tick = 0;
bool is_auto = false;
motor.is_slow = true;
//打开激光器
laser.init();
forever {
//按下模式键则退出当前功能, 返回模式选择用户界面
if( key.MODE_enable() ) {
motor.is_slow = false;
sound.play( sound.EXIT );
//关闭激光器
laser.init();
return;
}
//读取角度
buffer0 = buffer1;
buffer1 = buffer2;
buffer2 = current_angle;
current_angle = pendulum.read_angle();
current_angle += buffer2 + buffer1 + buffer0;
current_angle /= 4s;
//按下开始键则控制电机转到目标角度
if( key.FUNC_enable() ) {
is_auto = true;
motor.is_OK = false;
sound.play( sound.START );
}
//判断是否自动跟踪
if( is_auto ) {
motor.angle = (sint)seg[(uint)( current_angle + 100s )];
if( motor.is_OK ) {
out_led.flash( 3 );
sound.play( sound.OK );
is_auto = false;
}
}
//显示进程
++screen_tick;
if( screen_tick == 10 ) {
screen_tick = 0;
screen.show_s_number( motor.current_angle );
}
}
}
public void 激光笔自动跟踪()
{
sint16 buffer0 = 0s;
sint16 buffer1 = 0s;
sint16 buffer2 = 0s;
sint16 current_angle = 0s;
uint8 screen_tick = 0;
//打开激光器
laser.init();
forever {
//按下模式键则退出当前功能, 返回模式选择用户界面
if( key.MODE_enable() ) {
sound.play( sound.EXIT );
//关闭激光器
laser.close();
return;
}
//读取角度
buffer0 = buffer1;
buffer1 = buffer2;
buffer2 = current_angle;
current_angle = pendulum.read_angle();
current_angle += buffer2 + buffer1 + buffer0;
current_angle /= 4s;
motor.angle = (sint)seg[(uint)( current_angle + 100s )];
//显示进程
++screen_tick;
if( screen_tick == 10 ) {
screen_tick = 0;
screen.show_s_number( current_angle );
}
}
}
//激光笔跟踪曲线,根据一个事先推导的数学公式产生此表格
[200]u.code uint16 seg = {
181,180,178,176,175,173,172,170,168,168,
166,164,162,160,158,157,155,153,151,150,
148,146,143,141,139,137,135,133,130,129,
127,125,122,120,118,115,113,110,108,107,
104,102,100, 97, 95, 93, 91, 88, 86, 85,
83, 80, 78, 76, 74, 72, 70, 68, 66, 65,
63, 61, 59, 57, 56, 54, 52, 50, 49, 48,
46, 45, 43, 42, 40, 39, 37, 36, 34, 34,
32, 31, 30, 28, 27, 26, 24, 23, 22, 21,
20, 19, 18, 17, 15, 14, 13, 12, 11, 11,
10, 9, 8, 7, 6, 5, 4, 3, 2, 2,
1, 0,65535,65534,65533,65532,65531,65530,65529,65529,
65528,65527,65526,65525,65524,65523,65522,65521,65521,65521,
65520,65519,65518,65517,65516,65515,65514,65513,65513,65513,
65512,65511,65510,65509,65508,65508,65507,65506,65505,65505,
65504,65504,65503,65502,65501,65500,65499,65499,65498,65498,
65497,65496,65495,65495,65494,65493,65492,65491,65491,65491,
65490,65489,65488,65488,65487,65486,65485,65484,65484,65484,
65483,65482,65482,65481,65480,65479,65478,65478,65477,65477,
65476,65476,65475,65474,65473,65472,65472,65471,65470,65470
};
public void 自动保持平板水平()
{
uint8 screen_tick = 0;
forever {
//按下模式键则退出当前功能, 返回模式选择用户界面
if( key.MODE_enable() ) {
sound.play( sound.EXIT );
return;
}
sint16 a = pendulum.read_angle();
motor.angle = -a;
++screen_tick;
if( screen_tick == 10 ) {
screen.show_s_number( a );
}
}
}
} <br>
<br>红色
<br>红色<font color="#00FF00">绿色<font color="#0000FF">蓝色</font></font>
<br>
<br>好啦。
<br>
<br>程序：
<br>
<br>
<br>
<br><font color="#0000FF">void main()
<br>{
<br> int test = 34;
<br> while(1)
<br> {
<br> //应该是绿色的
<br> }
<br>}
<br></font>
<br>
页:
[1]