电子开发 | 基础入门 | 电路原理图 | 濮婎垰鑸伴崶鎯х杽娓氾拷 | PLC閸╄櫣顢�   閵嗗﹤顩ч弸婊冩灘濞嗐垺婀扮粩娆欑礉鐠囬攱瀵� Ctrl+D 閹靛濮╅弨鎯版閿涗焦鍔呯拫銏″亶閻ㄥ嫭鏁幐浣碘偓锟�娑撯偓鐠у嘲顒熸稊鐘辩鐠х柉绻樺銉礉閻㈤潧鐡欏鈧崣鎴犲竾濞嗐垼绻嬮幃顭掔磼.

电子开发网

电子开发网电子设计 | 电子开发网Rss 2.0 会员中心 会员注册

閳藉懐鏁哥捄顖氬彆瀵繑澧滈崘宀嬬礉閺堚偓閺傛壆澧楅妴濠勬暩鐎涙劗鏁哥捄顖氬彆瀵繗顓哥粻妤€娅掗妴瀣剁礉閻絻鐭鹃崗顒€绱¢弻銉嚄閹靛鍞� 閻絻鐭鹃崗顒€绱$拋锛勭暬閸c劊鈧劗鏁哥€涙劒绮犳稉姘眽閸涙ê绻€婢跺洦澧滈崘灞烩偓锟�
閳藉棗宕勬径鈺侇劅娴兼艾宕熼悧鍥ㄦ簚鐎圭偘绶�100 c鐠囶叀鈻� chm閺嶇厧绱¢妴鍌濈カ閺傛瑥鍞寸€圭顕涚紒鍡礉鐟曞棛娲婃笟瀣摍婢舵熬绱濋崘鍛啇楠炶¥鈧劗鏁哥€涙劒绮犳稉姘眽閸涙ê绻€婢跺洦澧滈崘灞烩偓锟�
搜索: 您现在的位置: 电子开发网 >> 编程学习 >> C语言 >> 正文

C语言写的俄罗斯方块程序

作者:佚名    文章来源:本站原创    点击数:1417    更新时间:2017/6/16

大概在最近两天之内编码完成,但此前一天开始构思。第一天晚上主要完成了方块旋转算法,第二天也就是今天加了消方块的处理算法。但是可能还有一些考虑不周的地方,比如,没有采用定时中断,而是图方便采用了和cpu频率有关的delay()函数来模拟时间间隔,这是需要改进的地方。
其中的主要逻辑有:
(1)由于c的随机性函数不好,所以每次游戏开始根据bios时间设置种子。
(2)得分越高,方块下降速度越快(每200分为单位)。
(3)每下落一个方块加1分,每消除一行加10分,两行加30分,三行加70分,四行加150分。初试分数为100分。
游戏控制:
   up-旋转;空格-下落到底; 左右下方向键-控制方向。P-开始或暂停游戏。 ESC-退出。
特点:
(1)由于tc不支持中文,所以基本都是英文注释。
(2)函数命名尽可能规范的表达其内部处理目的和过程。
(3)代码加上注释仅有577行。(我下载过的两个俄罗斯方块代码一个在1087行,一个在993行,我的比它们代码少)。
(4)除了消除空格时算法比较复杂,其他算法都比较简单易读。
(5)绘图效率和局部代码效率扔有待提高。
(6)FrameTime参数可能依据不同硬件环境进行具体设置,InitGame需要正确的TC路径。

    俄罗斯方块源于大约9年前上大一时的一个梦,我们在学习c语言时,我的同寝室友邀请我合作一起完成俄罗斯方块(课外作业性质),但是当时限于我们的水平比较菜和学习状态比较懒散,我们没有完成。大一的时候我在机房里无意发现别人留下的俄罗斯方块程序,运行,老师发现后激动的问我是我写的吗,我惭愧的摇摇头。那时看到别人做c的大程序深感羡慕(自己只是写几十行的程序)。数年后我仍然看到有不同样式的实现,但是我一直没有实现它,知道今天忽然有这个想法去做,算是弥补多年前的遗憾和心愿吧。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
//-----------------------【以下是我的代码文件:】---------------------
/********************************/
/* Desc:    俄罗斯方块游戏                */
/* By:        hoodlum1980                */
/* Email:    jinfd@126.com            */
/* Date:    2008.03.12 22:30            */
/********************************/
#include <stdio.h>
#include <bios.h>
#include <dos.h>
#include <graphics.h>
#include <string.h>
#include <stdlib.h>
#define true         1
#define false         0
#define BoardWidth    12
#define BoardHeight     23
#define _INNER_HELPER
/*inner helper method */
/*Scan Codes Define*/
enum KEYCODES
{
    K_ESC                =0x011b,
    K_UP                =0x4800,        /* upward arrow */
    K_LEFT            =0x4b00,
    K_DOWN            =0x5000,
    K_RIGHT            =0x4d00,
    K_SPACE            =0x3920,
    K_P                =0x1970
};
/* the data structure of the block */
typedef struct tagBlock
{
    char c[4][4];    /* cell fill info array, 0-empty, 1-filled */
    int x;                /* block position cx [ 0,BoardWidht -1] */
    int y;                /* block position cy [-4,BoardHeight-1] */
    char color;        /* block color */
    char size;        /* block max size in width or height */
    char name;        /* block name (the block's shape) */
} Block;
/* game's global info */
int FrameTime= 1300;
int CellSize= 18;
int BoardLeft= 30;
int BoardTop=    30;
/* next block grid */
int NBBoardLeft= 300;
int NBBoardTop=    30;
int NBCellSize=  10;
/* score board position */
int ScoreBoardLeft= 300;
int ScoreBoardTop=100;
int ScoreBoardWidth=200;
int ScoreBoardHeight=35;
int ScoreColor=LIGHTCYAN;
/* infor text postion */
int InfoLeft=300;
int InfoTop=200;
int InfoColor=YELLOW;
int BorderColor=DARKGRAY;
int BkGndColor=BLACK;
int GameRunning=true;
int TopLine=BoardHeight-1;    /* top empty line */
int TotalScore=100;
char info_score[20];
char info_help[255];
char info_common[255];
/* our board, Board[x][y][0]-isFilled, Board[x][y][1]-fillColor */
unsigned char Board[BoardWidth][BoardHeight][2];
char BufferCells[4][4];    /* used to judge if can rotate block */
Block curBlock;        /* current moving block */
Block nextBlock;    /* next Block to appear */
/* function list */
int GetKeyCode();
int CanMove(int dx,int dy);
int CanRotate();
int RotateBlock(Block *block);
int MoveBlock(Block *block,int dx,int dy);
void DrawBlock(Block *block,int,int,int);
void EraseBlock(Block *block,int,int,int);
void DisplayScore();
void DisplayInfo(char* text);
void GenerateBlock(Block *block);
void NextBlock();
void InitGame();
int PauseGame();
void QuitGame();
/*Get Key Code */
int GetKeyCode()
{
    int key=0;
    if(bioskey(1))
    {
        key=bioskey(0);
    }
    return key;
}
/* display text! */
void DisplayInfo(char *text)
{
    setcolor(BkGndColor);
    outtextxy(InfoLeft,InfoTop,info_common);
    strcpy(info_common,text);
    setcolor(InfoColor);
    outtextxy(InfoLeft,InfoTop,info_common);
}
/* create a new block by key number,
* the block anchor to the top-left corner of 4*4 cells
*/
void _INNER_HELPER GenerateBlock(Block *block)
{
    int key=(random(13)*random(17)+random(1000)+random(3000))%7;
    block->size=3;/* because most blocks' size=3 */
    memset(block->c,0,16);
    switch(key)
    {
        case 0:
            block->name='T';
            block->color=RED;
            block->c[1][0]=1;
            block->c[1][1]=1, block->c[2][1]=1;
            block->c[1][2]=1;
            break;
        case 1:
            block->name='L';
            block->color=YELLOW;
            block->c[1][0]=1;
            block->c[1][1]=1;
            block->c[1][2]=1, block->c[2][2]=1;
            break;
        case 2:
            block->name='J';
            block->color=LIGHTGRAY;
            block->c[1][0]=1;
            block->c[1][1]=1;
            block->c[1][2]=1, block->c[0][2]=1;
            break;
        case 3:
            block->name='z';
            block->color=CYAN;
            block->c[0][0]=1, block->c[1][0]=1;
            block->c[1][1]=1, block->c[2][1]=1;
            break;
        case 4:
            block->name='5';
            block->color=LIGHTBLUE;
            block->c[1][0]=1, block->c[2][0]=1;
            block->c[0][1]=1, block->c[1][1]=1;
            break;
        case 5:
            block->name='o';
            block->color=BLUE;
            block->size=2;
            block->c[0][0]=1, block->c[1][0]=1;
            block->c[0][1]=1, block->c[1][1]=1;
            break;
        case 6:
            block->name='I';
            block->color=GREEN;
            block->size=4;
            block->c[1][0]=1;
            block->c[1][1]=1;
            block->c[1][2]=1;
            block->c[1][3]=1;
            break;
    }
}
/* get next block! */
void NextBlock()
{
    /* copy the nextBlock to curBlock */
    curBlock.size=nextBlock.size;
    curBlock.color=nextBlock.color;
    curBlock.x=(BoardWidth-4)/2;
    curBlock.y=-curBlock.size;
    memcpy(curBlock.c,nextBlock.c,16);
    /* generate nextBlock and show it */
    EraseBlock(&nextBlock,NBBoardLeft,NBBoardTop,NBCellSize);
    GenerateBlock(&nextBlock);
    nextBlock.x=1,nextBlock.y=0;
    DrawBlock(&nextBlock,NBBoardLeft,NBBoardTop,NBCellSize);
}
/* rotate the block, update the block struct data */
int _INNER_HELPER RotateCells(char c[4][4],char blockSize)
{
    char temp,i,j;
    switch(blockSize)
    {
        case 3:
            temp=c[0][0];
            c[0][0]=c[2][0], c[2][0]=c[2][2],    c[2][2]=c[0][2], c[0][2]=temp;
            temp=c[0][1];
            c[0][1]=c[1][0], c[1][0]=c[2][1],    c[2][1]=c[1][2], c[1][2]=temp;
            break;
        case 4:    /* only 'I' block arived here! */
            c[1][0]=1-c[1][0], c[1][2]=1-c[1][2], c[1][3]=1-c[1][3];
            c[0][1]=1-c[0][1], c[2][1]=1-c[2][1],    c[3][1]=1-c[3][1];
            break;
    }
}
/* judge if the block can move toward the direction */
int CanMove(int dx,int dy)
{
    int i,j,tempX,tempY;
    for(i=0;i<curblock.size;i++) for(j="0;j<curBlock.size;j++)" if(curblock.c[i][j])="" {="" cannot="" move="" leftward="" or="" rightward="" *="" i="" +="" dx;="" if(tempx<0="" ||="" tempx="curBlock.x">(BoardWidth-1))    return false; /* make sure x is valid! */
                /* cannot move downward */
                tempY = curBlock.y + j + dy;
                if(tempY>(BoardHeight-1))    return false; /* y is only checked lower bound, maybe negative!!!! */
                /* the cell already filled, we must check Y's upper bound before check cell ! */
                if(tempY>=0 && Board[tempX][tempY][0]) return false;
            }
        }
    }
    return true;
}
/* judge if the block can rotate */
int CanRotate()
{
    int i,j,tempX,tempY;
    /* update buffer */
    memcpy(BufferCells, curBlock.c, 16);
    RotateCells(BufferCells,curBlock.size);
    for(i=0;i<curblock.size;i++) for(j="0;j<curBlock.size;j++)" {="" if(tempx<0="" ||="" tempx="curBlock.x+i;" if(buffercells[i][j])="" tempy="curBlock.y+j;">(BoardWidth-1))
                    return false;
                if(tempY>(BoardHeight-1))
                    return false;
                if(tempY>=0 && Board[tempX][tempY][0])
                    return false;
            }
        }
    }
    return true;
}
/* draw the block */
void _INNER_HELPER DrawBlock(Block *block,int bdLeft,int bdTop,int cellSize)
{
    int i,j;
    setfillstyle(SOLID_FILL,block->color);
    for(i=0;i<block->size;i++)
    {
        for(j=0;j<block->size;j++)
        {
            if(block->c[i][j] && (block->y+j)>=0)
            {
                floodfill(
                    bdLeft+cellSize*(i+block->x)+cellSize/2,
                    bdTop+cellSize*(j+block->y)+cellSize/2,
                    BorderColor);
            }
        }
    }
}
/* Rotate the block, if success, return true */
int RotateBlock(Block *block)
{
    char temp,i,j;
    int b_success;
    if(curBlock.size==2)
        return;
    if(( b_success=CanRotate()))
    {
        EraseBlock(block,BoardLeft,BoardTop,CellSize);
        memcpy(curBlock.c,BufferCells,16);
        DrawBlock(block,BoardLeft,BoardTop,CellSize);
    }
    return b_success;
}
/* erase a block, only fill the filled cell with background color */
void _INNER_HELPER EraseBlock(Block *block,int bdLeft,int bdTop,int cellSize)
{
    int i,j;
    setfillstyle(SOLID_FILL,BkGndColor);
    for(i=0;i<block->size;i++)
    {
        for(j=0;j<block->size;j++)
        {
            if(block->c[i][j] && (block->y+j>=0))
            {
                floodfill(
                    bdLeft+cellSize*(i+block->x)+cellSize/2,
                    bdTop+cellSize*(j+block->y)+cellSize/2,
                    BorderColor);
            }
        }
    }
}
/* move by the direction if can, donothing if cannot
* return value: true - success, false - cannot move toward this direction
*/
int MoveBlock(Block *block,int dx,int dy)
{
    int b_canmove=CanMove(dx,dy);
    if(b_canmove)
    {
        EraseBlock(block,BoardLeft,BoardTop,CellSize);
        curBlock.x+=dx;
        curBlock.y+=dy;
        DrawBlock(block,BoardLeft,BoardTop,CellSize);
    }
    return b_canmove;
}
/* drop the block to the bottom! */
int DropBlock(Block *block)
{
    EraseBlock(block,BoardLeft,BoardTop,CellSize);
    while(CanMove(0,1))
    {
        curBlock.y++;
    }
    DrawBlock(block,BoardLeft,BoardTop,CellSize);
    return 0;/* return value is assign to the block's alive */
}
/* init the graphics mode, draw the board grid */
void InitGame()
{
    int i,j,gdriver=DETECT,gmode;
    struct time sysTime;
    /* draw board cells */
    memset(Board,0,BoardWidth*BoardHeight*2);
    memset(nextBlock.c,0,16);
    strcpy(info_help,"P: Pause Game. --by hoodlum1980");
    initgraph(&gdriver,&gmode,"c:\\tc\\");
    setcolor(BorderColor);
    for(i=0;i<=BoardWidth;i++)
    {
        line(BoardLeft+i*CellSize, BoardTop, BoardLeft+i*CellSize, BoardTop+ BoardHeight*CellSize);
    }
    for(i=0;i<=BoardHeight;i++)
    {
        line(BoardLeft, BoardTop+i*CellSize, BoardLeft+BoardWidth*CellSize, BoardTop+ i*CellSize);
    }
    /* draw board outer border rect */
    rectangle(BoardLeft-CellSize/4, BoardTop-CellSize/4,
        BoardLeft+BoardWidth*CellSize+CellSize/4,
        BoardTop+BoardHeight*CellSize+CellSize/4);
    /* draw next block grids */
    for(i=0;i<=4;i++)
    {
        line(NBBoardLeft+i*NBCellSize, NBBoardTop, NBBoardLeft+i*NBCellSize, NBBoardTop+4*NBCellSize);
        line(NBBoardLeft, NBBoardTop+i*NBCellSize, NBBoardLeft+4*NBCellSize, NBBoardTop+ i*NBCellSize);
    }
    /* draw score rect */
    rectangle(ScoreBoardLeft,ScoreBoardTop,ScoreBoardLeft+ScoreBoardWidth,ScoreBoardTop+ScoreBoardHeight);
    DisplayScore();
    /* set new seed! */
    gettime(&sysTime);
    srand(sysTime.ti_hour*3600+sysTime.ti_min*60+sysTime.ti_sec);
    GenerateBlock(&nextBlock);
    NextBlock();    /* create first block */
    setcolor(DARKGRAY);
    outtextxy(InfoLeft,InfoTop+20,"Up  -rotate  Space-drop");
    outtextxy(InfoLeft,InfoTop+35,"Left-left    Right-right");
    outtextxy(InfoLeft,InfoTop+50,"Esc -exit");
    DisplayInfo(info_help);
}
/* set the isFilled and fillcolor data to the board */
void _INNER_HELPER FillBoardData()
{
    int i,j;
    for(i=0;i<curblock.size;i++) for(j="0;j<curBlock.size;j++)" {="" if(curblock.c[i][j]="" &&="" (curblock.y+j)="">=0)
            {
                Board[curBlock.x+i][curBlock.y+j][0]=1;
                Board[curBlock.x+i][curBlock.y+j][1]=curBlock.color;
            }
        }
    }
}
/* draw one line of the board */
void _INNER_HELPER PaintBoard()
{
    int i,j,fillcolor;
    for(j=max((TopLine-4),0);j<boardheight;j++) top="" {="" *="" fillcolor="Board[i][j][0]?" board[i][j][1]:bkgndcolor;="" setfillstyle(solid_fill,fillcolor);="" floodfill(boardleft+i*cellsize+cellsize="" 2,boardtop+j*cellsize+cellsize="" 2,bordercolor);="" check="" one="" line="" if="" filled="" full="" and="" increase="" totalscore!="" void="" _inner_helper="" checkboard()="" int="" i,j,k,score="10,sum=0,topy,lines=0;" we="" find="" the="" empty="" line!="" j="topy=BoardHeight-1;" do="" sum="0;" for(i="0;i<BoardWidth;i++)" boardwidth;="" i++)="" sum+="Board[i][topy][0];" topy--;="" }="" while(sum="">0 && topy>0);
    /* remove the full filled line (max remove lines count = 4) */
    do
    {
        sum=0;
        for(i=0;i< BoardWidth; i++)
            sum+=Board[i][j][0];
        if(sum==BoardWidth)/* we find this line is full filled, remove it! */
        {
            /* move the cells data down one line */
            for(k=j; k > topy;k--)
            {
                for(i=0;i<boardwidth;i++) top="" {="" move="" *="" one="" line="" the="" line!="" for(i="0;i<BoardWidth;i++)" }="" while(sum="" board[i][k][0]="Board[i][k-1][0];" board[i][k][1]="Board[i][k-1][1];" *make="" empty!="" board[i][topy][0]="0;" board[i][topy][1]="0;" topy++;="" topline="" downward="" lines++;="" lines="" <="4" totalscore+="score;" score*="2;" adding:="" 10,="" 30,="" 70,="" 150="" else="" j--;="">0 && j>topy && lines<4);
    /* speed up the game when score is high, minimum is 400 */
    FrameTime=max(1200-100*(TotalScore/200), 400);
    TopLine=topy;/* update the top line */
    /* if no lines remove, only add 1: */
    if(lines==0)
        TotalScore++;
}
/* display the score */
void _INNER_HELPER DisplayScore()
{
    setcolor(BkGndColor);
    outtextxy(ScoreBoardLeft+5,ScoreBoardTop+5,info_score);
    setcolor(ScoreColor);
    sprintf(info_score,"Score: %d",TotalScore);
    outtextxy(ScoreBoardLeft+5,ScoreBoardTop+5,info_score);
}
/* we call this function when a block is inactive. */
void UpdateBoard()
{
    FillBoardData();
    CheckBoard();
    PaintBoard();
    DisplayScore();
}
/* pause the game, and timer handler stop move down the block! */
int PauseGame()
{
    int key=0;
    DisplayInfo("Press P to Start or Resume!");
    while(key!=K_P && key!=K_ESC)
    {
        while(!(key=GetKeyCode())){}
    }
    DisplayInfo(info_help);
    return key;
}
/* quit the game and do cleaning work. */
void QuitGame()
{
    closegraph();
}
/* the entry point function. */
void main()
{
    int i,flag=1,j,key=0,tick=0;
    InitGame();
    if(PauseGame()==K_ESC)
        goto GameOver;
    /* wait until a key pressed */
    while(key!=K_ESC)
    {
        /* wait until a key pressed */
        while(!(key=GetKeyCode()))
        {
            tick++;
            if(tick>=FrameTime)
            {
                /* our block has dead! (can't move down), we get next block */
                if(!MoveBlock(&curBlock,0,1))
                {
                    UpdateBoard();
                    NextBlock();
                    if(!CanMove(0,1))
                        goto GameOver;
                }
                tick=0;
            }
            delay(100);
        }
        switch(key)
        {
            case K_LEFT:
                MoveBlock(&curBlock,-1,0);
                break;
            case K_RIGHT:
                MoveBlock(&curBlock,1,0);
                break;
            case K_DOWN:
                MoveBlock(&curBlock,0,1);
                break;
            case K_UP:
                RotateBlock(&curBlock);
                break;
            case K_SPACE:
                DropBlock(&curBlock);
                break;
            case K_P:
                PauseGame();
                break;
        }
    }
GameOver:
    DisplayInfo("GAME OVER!  Press any key to exit!");
    getch(); /* wait the user Press any key. */
    QuitGame();
}
//----------------------------------【代码文件结尾】--------------------------------------
</boardwidth;i++)></boardheight;j++)></curblock.size;i++)></block-></block-></block-></block-></curblock.size;i++)></curblock.size;i++)></stdlib.h></string.h></graphics.h></dos.h></bios.h></stdio.h>
Tags:C语言,俄罗斯方块程序  
责任编辑:admin
  • 上一篇文章: 没有了
  • 下一篇文章:
  • 请文明参与讨论,禁止漫骂攻击。 昵称:注册  登录
    [ 查看全部 ] 网友评论
        没有任何评论
    鐠у嫭鏋¢崠鍛瑓鏉烇拷
     [闁告娲滄晶鏍嫉妤﹁法銈柡鍌︽嫹]闁告ぞ绀侀妵澶屸偓娑崇細缁变即宕¢弴鐘差暬闁哄牆鎼悿鍕瑹閿燂拷100 c閻犲浄鎷�
     [闁活澀绲婚惌鐐鐠恒劍鍩傞悹浣瑰礃椤擄拷]LM324閺夆晜鍔栭弬锟�4~20mA閺夌儑鎷�1~5V闁汇垹鐏氱粊锟�
     [闁活澀绲婚惌鐐鐠恒劍鍩傞悹浣瑰礃椤擄拷]LM386濡炲湱绮悗顒佹媴閹捐顔婇柛蹇擃儔椤ユ捇寮ㄩ幆褋浜i柛锝冨妼鐢拷
     [闁活澀绲婚惌鐐鐠恒劍鍩傞悹浣瑰礃椤擄拷]936闁绘帒锕よぐ鎾偨娴e啰鐔呴柛妯煎枔閹﹪宕堕敓锟�
     [闁告娲滄晶鏍嫉妤﹁法銈柡鍌︽嫹]閻℃帒鎳庨敍鎰枖閵忥紕銈撮悹鐚存嫹+婵炴挴鏅涚€癸拷+闁硅翰鍎撮鐔兼儍閸曨偄绀�
     [闂侇偅姘ㄩ弫銈夋偨闂堟稓鎽嶉悹浣瑰礃椤撳憡娼娆愵偨]S7-200PLC闁汇劌瀚挒銏ゆ儑閻旀槒鎷ù鐙呮嫹 S7_2
     [閺夌儐鍨▎銏㈢尵閿燂拷]S7-200閹煎瓨鎸婚弸鍐╃鐠佸湱绀勯柛蹇g厜缁憋拷,STEP7
     [閺夌儐鍨▎銏㈢尵閿燂拷]ModbusPoll闁告粌顒爋dbusSalve闁稿骏鎷�
     [閺夌儐鍨▎銏㈢尵閿燂拷]STEP7婵☆垪鍓濈€氭瑩鏌岃箛鏂跨樄濞寸姰鍊曠花锟� Smart_
     [閺夌儐鍨▎銏㈢尵閿燂拷]Modbus閻犲鍟抽惁顖滃垝閸撗傜触 v1.024 缂備緤鎷�
     [閺夌儐鍨▎銏㈢尵閿燂拷]Modscan32闁告粌顒爋dsim32,modb
     [闁活澀绲婚惌鐐鐠恒劍鍩傞悹浣瑰礃椤擄拷]89c51闁稿繐顦遍悵娑㈠棘闁稖闆归柣顏嗗櫐缁辨獤rotues
     [闁活澀绲婚惌鐐鐠恒劍鍩傞悹浣瑰礃椤擄拷]濞戞挸娲ら崟楣冨储閸炴姰otues濞寸姾娉曞﹢锛勭矙鐎n亞纰嶆繝褎鍔楅悥锟�
     [闁活澀绲婚惌鐐鐠恒劍鍩傞悹浣瑰礃椤擄拷]51闁告娲滄晶鏍嫉閸濆嫬鍧婄紒瀣舵嫹 protues濞寸姾娉曞﹢锟�
     [闁活澀绲婚惌鐐鐠恒劍鍩傞悹浣瑰礃椤擄拷]闁告娲滄晶鏍嫉閿燂拷 PROTUES濞寸姾娉曞﹢锛勨偓鍦仒缁躲儲寰勯敓锟�
    关于我们 - 联系我们 - 广告服务 - 友情链接 - 网站地图 - 版权声明 - 在线帮助 - 文章列表
    返回顶部
    刷新页面
    下到页底
    晶体管查询