【EEWORLD带你DIY】具备VGA显示功能单片机学习板进展贴（4月15日已更新）

EEWORLD社区

【EEWORLD带你DIY】具备VGA显示功能单片机学习板进展贴（4月15日已更新） [复制链接]

缘起：
想要一款具备VGA显示功能的开发板？但是兜里的银子又不足。何不在wangkj的带领下，大家动手做做。通过这次活动，你可以获得：
　　1、资深工程师详尽的技术指导和讨论；
　　2、一群志同道合的朋友；
　　3、独立的动手能力以及分析问题、解决问题的方法；
活动主旨：用最简单的硬件，搭建最易学的公共学习/创业平台。

活动名称：DIY具备VGA显示功能单片机学习板
　　　　　这个版本的目的就是：学习！

活动周期：即日起—2009年12月31日

参与方式：
1、统筹：wangkj
2、其他参考资料收集、整理：2人；
3、 硬件设计：1人；
4、软件设计：不限；

报名参与页面：  https://www.eeworld.com.cn/formguide/index.php?formid=92

注：
积极参与者中，将有二十人可免费获赠PCB板一块（快递费自付）；
要求，只要会单片机，如51、arm、avr、pic、mips、ppc都可以。
          有足够的时间和精力；保证可以完成；乐于与大家分享；

如欲购买套件，可暂时不填，我们会在确定方案后第一时间公布购买方式。


－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－


Wangkj其人：
        开始了解wangkj，一个劲儿地说自己是搞技术的。结果，细细看了一遍他的帖子，天哪！简直一个天生为网络而生的人。以下为简要介绍：是嵌入式方面的高级工程师，擅长FPGA。网友眼中的wangkj：我觉得王工技术牛人，人又很厚道。 虽然话最少，但信息量最大呀 ！他在讲台上属于意识流，想到哪讲到哪。

windows下熟悉 delphi5.0写过的程序：
1.费用精细化管理软件2.xy2游戏外挂，破解的网络游戏，刷钱用的。没有最后完成，基本能跑了，后来没了兴趣。

Linux下:
1.组建linux发行版，就是做一个像windows xp一样的操作系统。
2.phlip arm7底层软件裸奔编程 提供各种外设的驱动和程序框架给应用软件组，
3.at91rm9200 除业务软件外所有软件的编写
4.独立完成独立运行的at91rm9200核心版设计
5.现在的兴趣：用cpld+sdram完成vga,3.5寸，7寸彩屏的显示和控制。

EEWORLD社区

2009-10-28 意见征集阶段：
准备DIY个具备VGA显示功能的学习版~~~大家给点建议？
https://bbs.eeworld.com.cn/thread-88276-1-2.html
DIY VGA活动硬件功能确定与选型讨论
https://bbs.eeworld.com.cn/thread-89445-1-1.html

初步规划：

    第一阶段：前期准备
                1．讨论可能需要的技术，并报名创建实施团队（已完成）
                2．硬件、软件方案讨论并确定（已完成）
                3．活动成员预报名（正在进行...... ）

    第二阶段：硬件制作调试发布
               1．原理图(确定版本：https://bbs.eeworld.com.cn/thread-90402-1-1.html）
               2．准备物料：烧写线已经搞定。
               3．PCB（ 硬件PCB板草图，先发出来，期待板砖 https://bbs.eeworld.com.cn/thread-101506-1-1.html）
               4．样板焊接、调试
               5．外设测试
    第三阶段：软件制作发布
               1．整合
               2．键盘接口
               3．快速画线      
               4．画圆
               5．填充等
               
    第四阶段：总结
     1．交流心得经验：
       41楼wangkj经典话语：不怕学不会，就怕不学！

lovedata

好活动，第一个报名！软件设计

lovedata

买元器件麻烦，还是买套件吧！

lzcqust

支持一下，我是新手，有个问题想问下：VGA显示用什么来实现？

wangkj

这个ip core我会写好，相当于现成的显示控制集成电路。
外围仅仅需要一个单片机就够了。

wangkj

实拍，局部放大

wangkj

这是我做的原型，已经调试成功，大家只需要按照这个原型改就可以了

wangkj

/*******************************************
单片机显卡测试程序
硬件规格：
stc51单片机主控，cpld+sdram实现显卡硬件，
这是stc51的主控程序。

by
wangkj@yahoo.com
qq:1248780
群：630571
create 2009-07-10
version 0.1
STC5205AD
*******************************************/


//#include "REG51F.H"
//#include
#include
#include
#include
#include

sbit MCU_IR_PWM        = P3^7;
sbit _CS = P1^4;                        // SPI总线的片选信号线
sbit SPCK= P1^7;                        // SPI总线的钟信号线
sbit MOSI= P1^5;                        // SPI总线的串行数据输出线
sbit EA0 = P1^6;                        // 地址/数据选择

#define                TRUE                1
#define                FALSE                0
#define     WIDTH       1024
#define     HIGH        768
//#define     nop()  _nop_

#define     LOGO_DIAPLMENT                     64      //每次位移的像素
#define     SCREENSAVE_WIDTH                1024    //大屏幕的宽、高
#define     SCREENSAVE_HIGH                   768
#define     LOGO_WIDTH                           88     //logo的宽、高
#define     LOGO_HIGH                              24


volatile unsigned  int data TimerCounter=0;

/********************************************/
/*          定时器 0 中断服务               */
/* 说明:  100us 中断一次， 优先级最高                */
/********************************************/

void  Timer0_Int(void) interrupt 1 using 1 //自动reload方式,10us
{
       
        TimerCounter++;
}

//延时1ms

void nop()
{
   unsigned char data i;
   for (i=0;i<1;i++)
   {
   }
//   _nop_ ;
}

void udelay(void)
{
   unsigned char data i;
   for (i=0;i<10;i++);
}

void delay1ms(void)
{
   unsigned  int data OldTimerCounter;
   OldTimerCounter = TimerCounter;
   while((TimerCounter-OldTimerCounter)<100)//
   { //如果调试,请把1换成不同到值，1是延时1ms,误差很小
        MCU_IR_PWM=~MCU_IR_PWM;
   }
   
}
/*从SPI总线上读入一个字节
unsigned int spi_read16(void)
{
        unsigned int data inData;
        unsigned char data i;
        for(i=0; i<8; i++)        // 移8次
        {       
                SCK = 0;                // 拉低时钟线
                inData <<= 1;       
                inData |= MO;        // 从SPI总线的数据输出线SO上读入一位
                SCK = 1;                // 拉高时钟线
        }
        return(inData);
} */        // python:  for i in range(1,15): hex(i*1024+i)
/*输出一个字节到SPI总线上*/
void spi_write8(unsigned char data outData)
{
   char i,j;
   for(i=0; i<8; i++)
   {
        
                SPCK = 0;               
                if ((outData & 0x80)==0)
                  MOSI=0;
                else
                  MOSI=1;
                //delay1ms();  
                for(j=0;j<3;j++);   
                SPCK = 1;
                for(j=0;j<3;j++);
                //delay1ms();
                   outData <<= 1;
               
/*                outData <<= 1;               
                SPCK = 1;  
                MOSI = CY;
                SPCK = 0;         */  
   }
   SPCK = 0;
/*  for(i=0; i<8; i++)                // 移8次
        {
//                outData <<= 1;
//                MOSI = CY;               
                SPCK = 1;        
                if ((outData & (0x80>>i))==0)
                  MOSI=0;
                else
                  MOSI=1;                
       
                        // 移出一位，送出至SPI总线的数据输出MOSI上
                SPCK = 0;       
        } */
}/*读SPI器件的状态*/
void spi_write16(unsigned int  outData)
{
   union
   {
      unsigned int  Data16;
          unsigned char Data8[2];
   } spi8;
   spi8.Data16=outData;
   spi_write8(spi8.Data8[0]);         //high
   spi_write8(spi8.Data8[1]);   //low
}
void cursor(unsigned int x,y)  //设置显存地址 8M 寻址空间。
{
   unsigned long int addr;
   addr=1L*(long)y*WIDTH+(long)x;
   EA0=1;//set cmd status
   //addr=272*y+x;
   spi_write16((unsigned int)(addr&0xfff));    //low
   spi_write16((unsigned int)((1<<12)|((addr>>12)&0xfff)));    //high

   EA0=0;//set data status        PutCmd(0);//reset display ram pointer to 0
}
void cursor2(unsigned long int addr)  //设置显存地址 8M 寻址空间。
{
   EA0=1;//set cmd status
   //addr=272*y+x;
   spi_write16(addr&0xfff);    //low
   spi_write16((1<<12)|((addr>>12)&0xfff));    //high

   EA0=0;//set data status        PutCmd(0);//reset display ram pointer to 0
}
void clr_scr(void)
{
   unsigned char i,j,k;  

   cursor(0,0);       
   //addr= 1L*WIDTH*HIGH*8*2;  
   MOSI=0;
   for(i=0;i<13*16;i++)
     for(j=0;j<255;j++)
           for(k=0;k<255;k++)   
         {SPCK=1;SPCK=0;}
}
void clr_scr64k(void)
{
   unsigned char i,j,k;         
   //addr= 1L*WIDTH*HIGH*8*2;  
   MOSI=0;
   for(i=0;i<16;i++)
     for(j=0;j<255;j++)
           for(k=0;k<255;k++)   
         {SPCK=1;SPCK=0;}
}
void putch(unsigned int x,y,unsigned char ch)
{
  unsigned char i,j;
  for(i=0;i<32;i++)
  {
    cursor(x,y+i);
        for(j=0;j<8;j++)
        {
      if (((num[ch*64+i*2]<             spi_write16(0x1f);
          else
            spi_write16(0);
    }
        for(j=0;j<8;j++)
    {
          if (((num[ch*64+i*2+1]<             spi_write16(0x1f);
          else
            spi_write16(0);
        }
  }
}   /*
void screensave(void){

       static  int pos_count_x =0 , pos_count_y=0;

       static  int x_last_state =1,  y_last_state = 1;//初始状态      

         if (pos_count_x < LOGO_DIAPLMENT)
                x_last_state = 1;
         else if (pos_count_x >= SCREENSAVE_WIDTH - LOGO_WIDTH - LOGO_DIAPLMENT)
                x_last_state = 2;

        if (pos_count_y < LOGO_DIAPLMENT)
                y_last_state = 1;
         else if (pos_count_y >= SCREENSAVE_HIGH - LOGO_HIGH - LOGO_DIAPLMENT)
                y_last_state = 2;
      


            if (y_last_state == 1)
                pos_count_y += LOGO_DIAPLMENT;
          else
                pos_count_y -= LOGO_DIAPLMENT;

           if (x_last_state == 1)
                pos_count_x += LOGO_DIAPLMENT;
            else
                pos_count_x -= LOGO_DIAPLMENT;


                      for(y=500;y<768;y+=24)
           for(i=0;i<24;i++)                 //显示图片,汉字测试
           {
             cursor(100+y,y+i);                 //光标移动一次，连续输入数据，速度较快
                for (j=0;j<88/8;j++)  
           for (k=0;k<8;k++)
            {
              if (((pic[i*(88/8)+j]<<(k)&0x80)==0x80))
                 { spi_write16(0xffff); }
              else
                 { spi_write16(0x0);    }            
            }
            }

                          
}           */
//主程序
void main(void)
{
                                   
unsigned  int  i,j,k,kkk;//OldTimerCounter;
unsigned long int x,y;
// unsigned char ch;//        cmd,
// unsigned int j;

P1M0=0x00;           //准双向口
P1M1=0x00;          
// AUXR = 0x40;  //可能不能位寻址以及OR,AND 操作，待验证
//AUXR=0x20;//6x UART  速度
AUXR=0x40|0x80; //T0,T1 12X
// AUXR=0x40;
//T0 正常 T1/1 12倍速, UART正常 ,禁用ADC,SPI，低压中断。
/***********************************************
AUXR 地址8EH 复位值=xxxx xx00B

7     6     5         4     3    2     1      0
T0x12 T1x12 UART_M0x6 EADCI ESPI ELVDI            - - 0000,00xx
定时器0 和定时器1:
STC12C5410AD 和STC12C2052AD 系列是 1T 的8051 单片机，为了兼容传统8051，定时器0 和定时器1 复
位后是传统8051 的速度，即12 分频，这是为了兼容传统8051。但也可不进行12 分频，实现真正的1T。
T0x12: 0, 定时器0 是传统8051 速度，12 分频；1, 定时器0 的速度是传统8051 的12 倍，不分频
T1x12: 0, 定时器1 是传统8051 速度，12 分频；1, 定时器1 的速度是传统8051 的12 倍，不分频
如果UART 串口用定时器1 做波特率发生器，T1x12 位就可以控制UART 串口是12T 还是1T 了。
UART 串口的模式0:
STC12C5410AD 和STC12C2052AD 系列是 1T 的8051 单片机，为了兼容传统8051，UART 串口复位后是兼容
传统8051 的。
UART_M0x6: 0, UART 串口的模式0 是传统12T 的8051 速度，12 分频；
1, UART 串口的模式0 的速度是传统12T 的8051 的6 倍，2 分频
如果用定时器T1做波特率发生器时,UART串口的速度由T1的溢出率决定
EADCI: 0, 禁止A/D 中断； 1，允许A/D 中断
ESPI: 0, 禁止SPI 中断； 1，允许SPI 中断
ELVDI: 0, 禁止低压中断； 1，允许低压中断
5V 单片机，3.7V 以下为低压，3V 单片机，2.4V 以下为低压，
如ELVDI=1（允许低压中断），则会产生低压中断，现版本无低压检测中断，是低压复位。
STC12C5410AD 系列无低压检测中断,只有STC12C2052AD 系列单片机才有低压检测中断。
*************************************************/
// 28.636晶振，bps 2400 误差 0.21% STC5410可以12倍速T1,

wangkj

// T0 标准51方式，做 1ms 基准时间用

  PCON=0x80;  //12倍T1 *  2 倍 bps 2400*12*2=57600
//  PCON=0x00; //正常操作，没有倍速
/***********************************************
7    6     5    4   3   2   1  0
SMOD SMOD0 LVDF POF GF1 GF0 PD IDL
POF：上电复位标志位，单片机停电后，上电复位标志位为1 ，可由软件清0 。
    实际应用：要判断是上电复位（冷启动），还是外部复位脚输入复位信号产生的复位，还是内部看门狗复位
P D： 将其置1 时，进入Power Down 模式，可由外部中断低电平触发或下降沿触发中断模式唤醒。
    进入掉电模式时，外部时钟停振，CPU、定时器、串行口全部停止工作，只有外部中断继续工作。
IDL：将其置1，进入IDLE 模式（空闲），除CPU 不工作外，其余仍继续工作，可由任何一个中断唤醒。
    现C 版本开始大量供货，C 版本IDLE 模式可正常使用（原A 版本和B 版本建议不要用IDLE 模式）。
GF1,GF0: 两个通用工作标志位,用户可以任意使用。
SMOD： 波特率倍速位，置1，串口通讯波特率快一倍
***********************************************/
// SMOD=1;
  IE=0x00;  //disable all interrupt   
/************************************************
IE(0A8H)
7  6   5  4  3   2   1   0
EA EC ET2 ES ET1 EX1 ET0 EX0
使能位=1 使能中断
使能位=0 禁止中断
位标号功能
IE.7 EA 全局禁止位如果EA=0 禁止所有中断如果EA=1 通过置
位或清除使能位对应的每个中断被使能或禁止
IE.6 EC PCA中断使能位
IE.5 ET2 定时器2 中断使能位
IE.4 ES 串行口中断使能位
IE.3 ET1 定时器1 中断使能位
IE.2 EX1 外部中断1 使能位
IE.1 ET0 定时器0 中断使能位
IE.0 EX0 外部中断0 使能位
*************************************************/
  IP=0x02;  //Timer0 is first level of interrupt
/**********************************************  
IP(0B8H) 7 6 5 4 3 2 1 0
PT2 PS PT1 PX1 PT0 PX0
中断优先级控制位=1 定义为高优先级中断
中断优先级控制位=0 定义为低优先级中断
IP.6 PPC PCA中断优先级控制位
IP.5 PT2 定时器2 中断优先级控制位
IP.4 PS 串行口中断优先级控制位
IP.3 PT1 定时器1 中断优先级控制位
IP.2 PX1 外部中断1 中断优先级控制位
IP.1 PT0 定时器0 中断优先级控制位
IP.0 PX0 外部中断0 中断优先级控制位
************************************************/
  TMOD=0x22; //T0,T1 8 bit Reload
            
/***********************************************
TMOD 地址：89H 不可位寻址 复位值：00H
7    6   5  4  3    2   1  0
GATE C/T M1 M0 GATE C/T M1 M0
定时器1 定时器0
位符号 功能
TMOD.7/ GATE TMOD.7 控制定时器1,置1 时只有在INT1 脚为高及TR1 控制位置1 时才可打开定时器/ 计数器1。
TMOD.3/ GATE TMOD.3 控制定时器0,置1 时只有在INT0 脚为高及TR0 控制位置1 时才可打开定时器/ 计数器0。
TMOD.6/ C/T TMOD.6  控制定时器1 用作定时器或计数器，清零则用作定时器（从内部系统时钟输入），
                    置1 用作计数器（从T1/P3.5 脚输入）
TMOD.2/ C/T TMOD.2  控制定时器0 用作定时器或计数器，清零则用作定时器（从内部系统时钟输入），置1
                    用作计数器（从T0/P3.4 脚输入）
                    
TMOD.5/TMOD.4 M1、M0 定时器定时器/计数器1模式选择
0 0   13位定时器/ 计数器，兼容8048 定时器模式，TL1 只用低5 位参与分频，TH1 整个8 位全用。
0 1   16位定时器/ 计数器，TL1、TH1 全用
1 0   8 位自动重装载定时器，当溢出时将TH1 存放的值自动重装入TL1。
1 1   定时器/ 计数器1 此时无效（停止计数）。
TMOD.1/TMOD.0 M1、M0 定时器/ 计数器0 模式选择
0 0   13位定时器/ 计数器，兼容8048 定时器模式，TL0 只用低5 位参与分频，TH0 整个8 位全用。
0 1   16位定时器/ 计数器，TL0、TH0 全用
1 0   8位自动重装载定时器，当溢出时将TH0 存放的值自动重装入TL0。
1 1   定时器0 此时作为双8 位定时器/ 计数器。TL0 作为一个8 位定时器/ 计数器，通过标准定时器0
      的控制位控制。TH0 仅作为一个8 位定时器,由定时器1 的控制位控制。


***********************************************/
  TH1=BAUD_2400;                 //设置串口的波特率为2400 for OSC 28.636Mhz//19200 for 29.08M
  TL1=BAUD_2400;                 //It Will be 2400*12*2 = 57600              //19200*6-115200 6x UART模式
/**********************************************
  串行口在方式1和方式3的波特率可变，与定时器T1或T2的溢出速率有关。51子系列
’常用定时器T1作为波待率发生器，这时方式1和方式3的波特率由定时器Tl的溢出率
确定
***********************************************/

  SCON=0x42;  //8bit variable,无多机通讯，REN=0,disable receive and set TI to generate serial send interupt
              //else the serial interupt will not work.
/**********************************************
  sc0N是一个可位寻址的专用寄存器，用来设定串行口的工作方式、控制串行口的接收
’发送以及状态标志。SCON的字节地址为98H，位地址为98H一9FH。其格式如下：
    D7  D6  D5  D4  D3  D2  Dl  D9
    SM0 SM1 SM2 REN TB8 RB8 TI  RI
各位的定义说明如下
SMO SCON.7  Serial Port mode specifier.(NOTE 1).
SM1 SCON.6  Serial Port mode specifier.(NOTE 1).
SMO SM1 Mode Description baud Rate
0   0   0    SHIFT REGISTER FOSC/12
0   1   1    8-BitUART      Variable
1   0   2    9-BitUART      Fosc/64 or Fosc/32
1   1   3    9-BitUART      Variable
SM2 SCON.5  
  在工作方式2和方式3中允许多机通信控制位。若SM 2置1，则允许多机通
信。当串行口以方式2或方式3接收时，若SM2＝1，且接收到的第9位数据(RB8)为l，则
接收到的前8位数据送入SBUF，并置位RI产生中断请求；否则，RI＝o，接收到的前8位数
据丢失。而当sM2＝o时，则不管RB8是o还是1，都将前8位数据装入SBUF中，并产生中
断请求。
  在方式1中，若SM2＝1，则只有接收到有效的停止位时，RI才置1，否则RI 0
在方式o中，SM2必须为o。
REN SCON.4  允许串行接收位。该位由软件置位或清除。REN＝1时，允许接收；REN＝o时，禁止接收
TB8 SCON.3  
在工作方式2或方式3时，该位为发送的第9位数据，可按需要由软件置位或
清零。在许多通信协议中，该位常作为奇偶校验位。在Mc5—5l多机通信中，TB8的状态用
来表示发送的是地址帧还是数据帧，TB8＝o时，为地址帧，TB8＝1时，为数据帧。
RB8 SCON.2
在工作方式2或方式3时，存放接收到的第9位数据，代表着接收效据的某种
特征。例如，可能是奇偶位，或为多机通信中的地址／数据标识位。在方式o中，RB8未用；在
方式1中，若SM2＝o，RB8是已接收到的停止位。
TI SCON.1     
发送中断标志。方式0中，串行发送完第8位数据后，由硬件置位；在其它方
式中，在发送停止位开始时，由硬件置位。TI＝1时，表示帧发送结束，其状态既可供软件查
询使用，也可申请中断。在任何方式中，TI都必须由软件清0。
RI SCON.O
接收中断标志。在方式o中，接收完第8位数据后，由硬件置位；在其它方式中，
在接收到停止位的中间时由硬件置位。RI＝1时，表示帧接收结束，其状态既可供软件查询
使用，也可申请中断。RI也必须靠软件清o。
when reset ,SCON=0;
***********************************************/
  REN=1;      //enable serial receive

  TH0=256-111; //1000000/(11.0592*1000*1000/111)=10.04 us
  TL0=256-111;                                
  TR0=1;
  TR1=1; //TCON=0x50;//0B01010000;  //Timer1 enable    Timer0 enable,No external INT
  ET0=1; //enable Timer0 interupt
//  ET1=1; //enable Timer1 interupt
  ES=1;  //enable serial interupt
  EA=1;  //enable  interupt
/*************************************************
    TCON作为定时器／汁数器的技制寄存器，其功能是控制定时器T0或T1的运行或停
止,标志定时器的溢出和中断情况。
TCON: TIMER/COUNTER CONTROL REGISTER. BIT ADDRESSABLE.
        TFl TR1  TFO  TRO  IE1  IT1  IEO  ITO
位地址  8FH  8xH  8DH  8CH  8BH  8AH  89H  88H
    (1)TF1(TCON．7)：定时器T1溢出标志。TI溢出时，由硬件自动使置1，并向
CPU申请中断。当进入个断服务程序时，硬件自动将TFl清0。TFl也可以用软件清0。
    (2)TR1(TCON．6)；定时器T1运行控制1位。由软件来置1或清0。 1启动工作,0停止。
    (3)TF0(TCON．5)：定时器T0溢出标志。
    (4)TR0(TCON．4)：定时器T0控制位
    (5)IE1(TCON．3)：外部中断1(INT1)请求标志。
    (6)IT1(TCON．2)：外部中断1触发方式选择位。
    (7)1E0(TCON .l)：外部中断0(INT0)请求标志。
    (8)IT0(TCON．0)：外部中断0触发方式选择位。当ITo＝o时，为电平触发方式当ITo＝1时，为边沿触发方式
           检测到由高到低的负跳变，，则置IEo标志为1，表示外部中断o正在向CPU申请中断必须保证外部中断源输人的高电平
       和低电平的持续时间在12个时钟周期以上
    TCON中的低四位(1E1、ITl、IE0,IT0)与中断有关
TCON.7 Timer 1 overflow flag. Set by hardware when the Timer/Counter 1 overlows.Cleared by hardware
processer vectors to the interrupt service routine.
TCON.6 Timer 1 run control bit. Set/cleared by software to turn Timer/Counter 1 ON/OFF.
TCON.5 Timer O overflow flag. Set by hardware when the Timer/CounterO overflows.Cleared by hsrdware
proceaser vectors to the service routine.
TCON.4 Timer O run control bit. Set/cleared by software to turn Timer/Counter O ON/OFF.
TCON.3 External Interrupt 1 edge flag. Set by hardware when External Interrupt edge is detected.
Cleared by hardware when interrupt is processed.
TCON.2 Interrupt 1 type control bit. Set/cleared by sotlwsre to specify falling edge flow level triggered
External Interrupt.
TCON. 1 External Interrupt O edge flag.Setby hardware when External Interrupt edge deteeted.Cleared
by hardware when interrupt is proeeased.
TCGN.O Interrupt O type control bit. Set/cleared by sotlwsre to specify fsfling edge/low level triggered
External Interrupt.
**************************************************/
  char_init();
/*  i=0;
    for(i=0;i<100;i++)//延时1s,等待所有的机器都启动
{       send_char(i);
       Delay1ms();
}
*/

  SPCK=0;
  while(1)
  {
//   if ((char_can_read()>=1))
   if ((1))
             {
//      cmd=get_char();
//            if (cmd==0x0a) //pc发送不同的命令字，可以执行不同的操作
//            if (cmd=='a') //pc发送不同的命令字，可以执行不同的操作
                //for(j=0;j<10000;j++)  delay1ms();
                //EA0=0;
                //delay1ms();
                //EA0=1;   
                //spi_write16(0);
                EA0=1;                          //reset
                spi_write16(0);
                spi_write16(0xffff);spi_write16(0xffff);spi_write16(0xffff);spi_write16(0xffff);//reset command
                spi_write16(0);
                EA0=0;

wangkj

for(j=0;j<50;j++)                
                  delay1ms();
        cursor(0,0);
        clr_scr();

//                for (j=0;j<25000;j++) {delay1ms();}

                for(i=0;i<1024;i++)                         //down
                  {
                    cursor(i,767);
                        spi_write16(0xffff);
                  }
                for(i=0;i<768;i++)
                  {
                    cursor(0,i);
                        spi_write16(0xffff);spi_write16(0x1f);spi_write16(0xff); //left//白 红 黄
                  }
                for(i=0;i<768;i++)
                  {
                    cursor(1021,i);        //1021,1022,1023
                    spi_write16(0x3f<<5);spi_write16(0xf800);        spi_write16(0xffff);//right        //绿 蓝 白
                  }         
                for(i=0;i<1024;i++)
                  {
                    cursor(i,0);
                        spi_write16(0xffff);         //up
                  }
           for(y=600;y<768;y+=24)
           for(i=0;i<24;i++)            //显示图片,汉字测试
           {             
                for (j=0;j<88/8;j++)  
           for (k=0;k<8;k++)
            {
                          cursor(y+j*8+k,y+i);          //光标移动一次，显示一个点，速度较慢
              if (((pic[i*(88/8)+j]<<(k)&0x80)==0x80))
                 { spi_write16(0xffff); }
              else
                 {spi_write16(0x0);    }            
            }
            }       

          
           for(y=600;y<768;y+=24)
           for(i=0;i<24;i++)                 //显示图片,汉字测试
           {
             cursor(100+y,y+i);                 //光标移动一次，连续输入数据，速度较快
                for (j=0;j<88/8;j++)  
           for (k=0;k<8;k++)
            {
              if (((pic[i*(88/8)+j]<<(k)&0x80)==0x80))
                 { spi_write16(0x1f); }
              else
                 { spi_write16(0x0);    }            
            }
            }

                for (j=0;j<40;j++)                    //recentage
         for (i=1024/2-20;i<1024/2+20;i++)            
          {
            cursor(i,768/2-20+j);
            spi_write16(0xffff);
          }
        for (i=1024/2-20;i<1024/2+20;i++) //mid line
          {
            cursor(i,768/2);
            spi_write16(0);
          }
                for (j=0;j<35000;j++) {delay1ms();}       

                for(i=768/2-50;i<768/2+50;i++)                        //灰色方块
                {       
                for (j=1024/2-50;j<1024/2+50;j++)
                  { cursor(j,i);spi_write16(0x0821); }  //for(n=0;n<1;n++);清屏 延时用2足够了，如果硬件规格高，可以省略。
                }
                for(i=0;i<100;i++)                                          //红色方块
                {       
                cursor(1024/2-50,768/2-50+i);
                        for (j=0;j<100;j++)
                  { spi_write16(0x01f); }  //for(n=0;n<1;n++);清屏 延时用2足够了，如果硬件规格高，可以省略。
                }
               

           for(y=600;y<768;y+=24)
           for(i=0;i<24;i++)
           {
             
                for (j=0;j<88/8;j++)  
           for (k=0;k<8;k++)
            {
                          cursor(y+j*8+k,y+i);                //红色汉字图片，写点模式
              if (((pic[i*(88/8)+j]<<(k)&0x80)==0x80))
                 { spi_write16(0x1f); }
              else
                 {spi_write16(0);    }            
            }
            }       

                for(i=768/2-50;i<768/2+50;i++)                  //清除方块
                {       
                for (j=1024/2-50;j<1024/2+50;j++)
                  { cursor(j,i);spi_write16(0); }  //for(n=0;n<1;n++);清屏 延时用2足够了，如果硬件规格高，可以省略。
                }

                for (j=0;j<25000;j++) {delay1ms();}


                for(k=5;k<120;k+=7)
                {
        for (j=0;j<1000;j+=100)
        {
                  for(i=560;i<570;i++)
                  {
                         cursor(j,i);
                         spi_write16(0xff); spi_write16(0xff);
                         if(i==560)
                     {
                           putch(j+2+32,i-32,(unsigned char)(j%10)) ;         //个位
                   putch(j+2+16,i-32,(unsigned char)((j%100)/10)) ;  
                   putch(j+2,i-32,(unsigned char)(((j/100)))) ;
                         }   
              }
                }  //for(n=0;n<1;n++);清屏 延时用2足够了，如果硬件规格高，可以省略。

        for (j=0;j<1024;j+=50)
        {
                  for(i=570;i<580;i++)
                  {
                         cursor(j,i);
                         spi_write16(0x07e0);spi_write16(0x07e0);
              }
                }  //for(n=0;n<1;n++);清屏 延时用2足够了，如果硬件规格高，可以省略。
         for (j=0;j<1024;j+=20)
        {
                  for(i=580;i<590;i++)
                  {
                         cursor(j,i);
                         spi_write16(0xf800); spi_write16(0xf800);
              }
                }  //for(n=0;n<1;n++);清屏 延时用2足够了，如果硬件规格高，可以省略。

        for (j=0;j<1024;j+=10)
        {
                  for(i=590;i<600;i++)
                  {
                         cursor(j,i);
                         spi_write16(0x1f);  spi_write16(0x1f);
              }
                }  //for(n=0;n<1;n++);清屏 延时用2足够了，如果硬件规格高，可以省略。

              cursor(0,600);
                  //clr_scr64k();
                  putch(1024-16,768-32,(unsigned char)(k%10)) ;
              putch(1024-16-16,768-32,(unsigned char)(k/10)) ;  
                  for (j=0;j<3500;j++) {delay1ms();}               

                  for(i=600;i<650;i++)
                for (j=0;j<1024;j++)
                if ((i==j)||(i==j+k*5)||(i%k==0)||(j%k==0)||(i==0)||(j==0)||(j==1023)||(i==767))
                {
                                  cursor(j,i);
                                  spi_write16(0x07e0);
                                }  
                  cursor(0,0);//clear screen
                  for(i=0;i<650;i++)
                  {
                if (i==550)
                        {  i=600;    cursor(0,600);        }
                        for (j=0;j<1024;j++)
                //if ((i%k==0)||(j%k==0))
                if ((i==j)||(i==j+k*5)||(i%k==0)||(j%k==0)||(i==0)||(j==0)||(j==1023)||(i==767))
                {
                                  spi_write16(0x0821);  //delay1ms(); //灰色
                                 // spi_write16(0xffff);  //delay1ms();          //白色
                                  //for(y=0;y<3;y++) delay1ms();
                                }  
                else
                  { spi_write16(0x0);// for(y=0;y<3;y++) delay1ms();  
                                  }
                   }
        }
      }       
  }  
}

wangkj

现在需要做个使用的功能，比如电子钟啥的。

tyxjl

试着参加下，硬件方面的

bkkman

关注着........................................

莫恩

像素，刷新频率？

wangkj

那种单片机都行。
单片机和程序开源，都已经提供了，看以前的帖子。
这次是重新规划一版，上次是俺自己做的实验板，比较大，功能太多。不合适。

实现的指标：（注意，这是已经实现的，不要考虑重做)
刷新率：60,
分辨率:1024*768
色彩 RBG 565 真彩
接口：标准VGA
ipcore随芯片发送，如果有人搞定actel的烧写器，可以考虑部分开源。

分辨率极限：1920*1200*16bit 真彩

李伟

牛人，将DIY进行到底，

李伟

周立功公司提供的easyFPGA用的是并口下载，有原理图，不知有用否？

wangkj

连上a3p060,根本不识别。
zlg的usb接口的烧写器卖500，如果这个好使，谁还买呀。
估计zlg搞的陷阱。

sjl2001

rt，