You mainly simulate SPI, control it, and your hardware wiring diagram should not be wrong.
Now my computer can't hold the simulation. If you like, just me.
I will write one for you according to your hardware diagram.
QQ 2475 19442
You can do it in one byte, you know, your problem now is to send it.
I have a program with an analog display digital tube.
You extract what you want from the code.
# include & ltc 805 1f 3 10 . h & gt;
# include & ltstdio.h & gt
# include & ltmath.h & gt
# include & ltIntrins.h & gt
# include & ltabsacc.h & gt
/* * * * * * * * * * * * * * Analog SPI controls the digital tube * * * * * * * * * * * * * * *
sbit SPI 1 _ sh _ clk = p 1^4; //Analog SPI shift clock
sbit SPI 1 _ ST _ clk = p 1^5; //Analog SPI Latch Clock
sbit SPI 1 _ out _ OE = p 1^6; //Analog SPI output control
sbit SPI 1 _ data = p 1^7; //Analog SPI data output
/*************************************************************/
* * * * * * * * * * * * * Data definition of system operation * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
Unsigned character ADC _ date [4] = {0}; //Save the AD conversion values of the four potentiometers.
unsigned char dis PAM[8]= { 10, 10, 10, 10, 10, 10, 10 }; //Digital tube display cache
sbit down _ button = p3^3; //Down button
sbit up _ button = p3^4; //Raised key
Bit flash memory;
Sbit beef = p0^7;;
Bit control _ coordinate = 0;
Unsigned char kkk
Unsigned characters Hbeef, Lbeef
Unsigned int m = 0;; //m is mainly used as a control variable for additional counting.
Unsigned character code letter [] =
{
0x32,0x48,0x7a,0x 17,0x37,0x48,0x 12,0x32,0x7e,0x7a,0x37,0x6b,0x7e,0x7a
};
Unsigned character code seg[]={0x7e, 0x48, 0x3d, 0x6d, 0x4b, 0x67, 0x77, 0x4c, 0x7f, 0x6f, 0x00, 0x37, 0x1f};
//Digital pipe segment code 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, e, p.
Unsigned char code seg_only[]={0x04, 0x08, 0x40, 0x20, 0x 10, 0x02, 0x0 1, 0x80, 0x00}; //a b c d e f g DP
Unsigned int code table [15]={64260, 64400, 64524, 64580,
64684,64777,64820,64898,
64968,65030,65058,65 1 10,
65 157,65 178,652 17};
/************************************************************/
Unsigned character code SONG 1[]=
{
0x35,0x3 1,0x34,0x34,0x24,0x35,0x32,0x32,0x24,0x38,
0x44,0x58,0x48,0x34,0x3 1,0x34,0x34,0x24,0x38,0x34,
0x7F,0x32,0x34,0x32,0x34,0x24,0x38,0x34,0x24,0x38,
0x43,0x58,0x48,0x34,0x32,0x34,0x38,0x24,0x38,0x34,
0x7F,0x 16,0x4C,0x74,0x78,0x64,0x54,0x48,0x54,0x64,
0x58,0x44,0x34,0x24,0x38,0x24,0x 14,0x 12,0x2 1,0x 14,
0x78,0x68,0x3F,0x4C,0x74,0x78,0x64,0x52,0x42,0x48,
0x53,0x64,0x58,0x44,0x34,0x24,0x38,0x24,0x24,0x38,
0x44,0x58,0x48,0x3C,0x00
};
Unsigned character code SONG0[]={ // Happy birthday.
0X82,0X0 1,0X8 1,0X94,0X84,0XB4,0XA4,0X04,0X82,0X0 1,
0X8 1,0X94,0X84,0XC4,0XB4,0X04,0X82,0X0 1,0X8 1,0XF4,
0XD4,0XB4,0XA4,0X94,0XE2,0X0 1,0XE 1,0XD4,0XB4,0XC4,
0XB4,0X04,0X00
};
/*****************************************************
* * Function declaration section * *
*****************************************************/
/* * * * * * * * * * * * * * * * * * System Configuration Function Statement * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
void sysclk(void); //System clock initialization
void PIO _ Init(void); //I/O port initialization
void SPI _ Init(void); //SPI initialization
//void PWM(void); //PWM initialization
void t 0 1 _ init(void); //Timer0, 1 Initialization
Void interrupt _ init (void); //Interrupt initialization
void ADC _ INIT(void); //AD conversion initialization
Invalid delay (unsigned integer time); //Delay program
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
void Spel _ Count(unsigned int Putin _ Count,unsigned char LR); /////Putin_Count is plastic data within 10000.
//LR is the control of left and right digital tubes, and LR=0 left.
Voiled _ flash1(unsigned character speed);
Void led_flash2 (unsigned char speed); //Digital tube operation display
Void SPI_Write_Byte (unsigned character write _ byte);
//Analog SPI sends a byte to 595 for display.
Void coordinates (unsigned char X_radiation, unsigned char y _ radiation);
//Display coordinates
Void Sing_Song (unsigned char * p _ song);
//Music performance function
/****************************************************/
/****************************************************/
/****************************************************/
/*****************************************************
* * Main functions * *
*****************************************************/
Void main(void) // main program
{
PCA0MD & amp= ~ 0x40// Turn off the watchdog.
PIO _ initialization (); //I/O port initialization configuration
sysclk(); //System clock initialization configuration
t 0 1 _ init(); //Timer initialization configuration
//PWM();
SPI _ Init(); //SPI0DAT is the data register of SPI.
Interrupt _ Initialize (); //Interrupt initialization configuration
ADC _ INIT(); //AD conversion initialization
SPI 1 _ OUT _ OE = 0; //Allow 595 output
ad 0 busy = 1; //After initialization, start an AD conversion first.
Delay (1);
EA = 1; //Then turn on the interrupt.
Delay (1);
Beef = 0;
//Spel_count(20 10,0);
//Spel_count( 12 1, 1); //Both left and right digital tubes display 0 after starting.
/*
ADC_date[0] indicates that the AD conversion value in the left and right direction of the handle corresponds to the middle value of the input of P2.0, that is, 0x80c0.
ADC_date[ 1] indicates that the AD conversion value in the left and right direction of the handle corresponds to P2. 1, and the median input value is 0x8040.
ADC_date[2] indicates that the AD conversion value in the front-back direction on the right side of the handle corresponds to P2.2, and the median input value is 0x8340.
ADC_date[3] indicates that the AD conversion value in the front-back direction on the left side of the handle corresponds to P2.3, and the median input value is 0x7f04.
*/
//Sing _ Song(Song 0);
while( 1)
{
for(Hbeef = 0; Hbeef & lt8; Hbeef++)
dis PAM[Hbeef]= 10;
while( 1)
{
led _ flash 1( 120);
led _ flash 2( 120);
led _ flash 1(60);
led _ flash 1(60);
led _ flash 1(60);
led _ flash 1(60);
led _ flash 1(40);
Delay (200);
led _ flash 2(60);
led _ flash 2(60);
led _ flash 2(60);
led _ flash 2(60);
led _ flash 2(40);
Break;
}
kkk = 0; m = 0;
while( 1)
{
If(kkk==50) is broken;
Coordinate (0, kkk% 6);
}
kkk = 0; m = 7000
while( 1)
{
Spel_count(m,0);
If (m== 13000)
{ m = 0; kkk++; Break; }
//Spel_count(kkk,0);
Spel_count( 13000-m, 1);
}
while( 1)
{ Sing _ Song(Song 0);
Break;
}
}
}
/****************************************************/
/****************************************************/
/****************************************************/
/*****************************************************
* * System initialization function * *
*****************************************************/
Void sysclk(void) // internal crystal oscillator
{
OSCICL = 0xa3// 0x83
OSCICN = 0xc3// divided by 2
CLKSEL = 0x00
}
Void PIO_Init(void) // port configuration
{
P0MDIN = 0xff// analog input is prohibited, 0 is analog, and 1 is digital.
P0MDOUT = 0xff//0 is open drain, and 1 is push-pull (ff).
P0SKIP = 0xf0
p 1 mdin = 0x ff;
p 1m dout = 0xf 0; //The lower four bits are used for 138.
p 1 skip = 0x ff;
P2MDIN = 0xff// analog input is prohibited, 0 is analog, and 1 is a number.
P2MDOUT = 0xff//0 is open drain, and 1 is push-pull (ff).
P2SKIP = 0xff
P3MDIN = 0xff
P3MDOUT = 0xff// The lower four bits are used for 138.
XBR0 = 0x02
xbr 1 = 0x 40;
}
Void SPI_Init(void) //SPI initialization
{
SPI0CFG = 0x40
SPI 0 cn = 0x 0 1; //0000 00 1 The last bit is SPI enable bit, which works in three-wire host mode.
Spi0ckr = 0x2f//The SPI clock frequency is set to 150kHz 0x6f 0x2f.
}
void t0 1_init(void)
{
TCON = 0x 10; //0 10 1 0000 Timer0/1allowed to work.
TMOD = 0x 1 1; //Timer 0/ 1 works in 16-bit counting mode.
CKCON = 0x00// system clock 12 frequency division
TH0 = 0xf8//PCA 50Hz clock
TL0 = 0x00
th 1 = 0x 00;
TL 1 = 0x 00;
}
Void Interrupt_Init(void) // interrupt setting
{
IE = 0; //Allow Timer 0/ 1 Interrupt Request
IP = 0x08//SPI is a low priority.
}
void ADC_INIT(void)
{
AMX0P = 0x08//P2.0
AMX0N = 0x 1f; //Single-ended mode GND is a negative input.
Adc0cf = 0xfc/11111100 data is left aligned.
ADC0CN = 0x80// Enable AD conversion.
REF0CN = 0
}
/****************************************************/
/****************************************************/
/****************************************************/
/*****************************************************
* * User defined functions * *
*****************************************************/
//Separate data
void Spel _ Count(unsigned int Putin _ Count,unsigned char LR)
{
Control coordinate = 0; //Display in normal form
if(Putin _ Count & gt; = 10000)
{ tr 1 = 0;
If (! Flash)
{
dis PAM[0+4 * LR]= 1 1; //letter e
dis PAM[ 1+4 * LR]= 12; //letter p
dis PAM[2+4 * LR]= 12;
dis PAM[3+4 * LR]= 12;
Beef =1;
}
other
{
dis PAM[0+4 * LR]= 10; //letter e
dis PAM[ 1+4 * LR]= 10; //letter p
dis PAM[2+4 * LR]= 10;
dis PAM[3+4 * LR]= 10;
Beef = 0;
}
}
other
{
dis param[3+4 * LR]= Putin _ Count % 10;
if(Putin _ Count & gt; = 10)
{ dis PAM[2+4 * LR]=(Putin _ Count/ 10)% 10; }
else dis param[2+4 * LR]= 10;
if(Putin _ Count & gt; = 100)
{ dis PAM[ 1+4 * LR]=(Putin _ Count/ 100)% 10; }
else disp ram[ 1+4 * LR]= 10;
if(Putin _ Count & gt; = 1000)
{ dis PAM[0+4 * LR]=(Putin _ Count/ 1000)% 10; }
else dis param[0+4 * LR]= 10;
}
}
Voiled _ flash1(unsigned character speed)
{
Unsigned characters led_i, led _ j;;
Control coordinate = 0;
for(led _ I = 0; led _ i & lt20; led_i++)
{
for(led _ j = 0; led _ j & lt7; led_j++)
dis PAM[led _ j]= dis PAM[led _ j+ 1];
if(led _ I & lt; 10)
de param[7]= led _ I;
other
dis PAM[7]= 10;
Delay (speed);
}
}
Void led_flash2 (unsigned character speed)
{
Unsigned characters led_i, led _ j;;
Control coordinate = 0;
for(led _ I = 0; led _ i & lt20; led_i++)
{
for(led _ j = 7; led _ j & gt0; led_j -)
dis PAM[led _ j]= dis PAM[led _ j- 1];
if(led _ I & lt; 10)
de param[0]= led _ I;
other
dis PAM[0]= 10;
Delay (speed);
}
}
Void SPI_Write_Byte (unsigned character write byte)
{
Unsigned character k;
for(k = 0; k & lt8; k++)
{
SPI 1 _ DATA =(write _ byte & gt; & gt(7-k))& amp; 0x 0 1;
SPI 1 _ SH _ CLK = 1;
SPI 1 _ SH _ CLK = 0;
}
}
Empty coordinates (unsigned character X _ radiation, unsigned character Y _ radiation)
{unsigned charged radiation;
Control _ coordinate =1; //Display in the form of coordinates
For (radiation = 0; Radiation & lt8; Radiation++)
if(X_radiation==0)
Dis PAM[ radiation ]= Y _ radiation;
other
{
If (radiation! = X _ radiation-1)
Dis PAM[ radiation] = 8;
dis PAM[X _ radiation- 1]= Y _ radiation;
}
}
Voidsing _ song (unsigned char * p _ song)//Play music.
{
Unsigned character I = 0;;
Unsigned characters yfm, jpm
while(*(P_song+i))
{
jpm =(*(P _ song+I))& amp; 0x0f// beat value
yfm =((*(P _ song+I))& gt; & gt0x 04)& amp; 0x0f// Simple spectrum value
If(yfm) // Simple spectrum is 1, take the count value.
{
yfm-;
hbeef = TABLE[yfm]/256; //Take the high byte of the count value
th 1 = Hbeef;
lbeef = TABLE[yfm]% 256; //Take the low byte of the count value
TL 1 = Lbeef;
tr 1 = 1; //Start Timer 0
}
else { tr 1 = 0; Beef = 0; }//notation is 0, no pronunciation.
Spel_count(yfm,0);
Spel_count(jpm, 1);
Delay (jpm *100); //Beat delay
i++;
}
}
Void delay//Delay program
{unsigned int i, j;
for(I = 0; I & lt2000; i++)
{
for(j = 0; J< time; j++){ _ nop _(); _ nop _(); }
}
}
/****************************************************/
/****************************************************/
/****************************************************/
/*****************************************************
* * Interrupt service function * *
*****************************************************/
Void Timer 0 (void) interrupt1/Timer 0 interrupt service.
{
Unsigned character n;
TH0 = 0xe8
TL0 = 0x00
* * * * * * * * * * * * * * Display control part * * * * * * * * * * * * *
n = p 1; //Get the currently scanned column
n =(++ n)amp; 0x07
If(Control_Coordinate) // The display mode control bit is valid, that is, it is displayed in the form of coordinates.
SPI _ Write _ Byte(seg _ only[dis pram[n]]);
Otherwise, the//display mode control bit is invalid, that is, it is displayed in normal form.
SPI _ Write _ Byte(seg[dis pram[n]]);
P 1。 = 0xf8// After scanning, add 1 to the current column.
SPI 1 _ ST _ CLK = 1;
p 1 | = n; //Send a new bit.
SPI 1 _ ST _ CLK = 0; //Analog SPI is a latched output.
/**************************************************/
if(m % 200 = = 0){ flash = ~ flash; }//When the data exceeds the displayed digits, it flashes.
if(m % 25 = = 0)kkk++;
Switch (m%4)
{
Case 0: ADC _ date [0] = adc0h; //The array stores the AD conversion values in a staggered way, with the left and right 0x80c0.
AMX0P = 0x09//2. 1 is the actual input of AD.
ad 0 busy = 1;
Break;
Case1:ADC _ date [1] = adc0h; //Right Up and Down 0x8040
AMX0P = 0; //2.2 is the positive input of AD.
ad 0 busy = 1;
Break;
Case 2: ADC _ date [2] = adc0h; //Left Up and Down 0x8340
AMX0P = 0x0b//2.3 is the positive input of AD.
ad 0 busy = 1;
Break;
Case 3: ADC _ date [3] = adc0h; //Right, Left and Right 0x7f04
AMX0P = 0x08//2.0 is the positive input of AD.
ad 0 busy = 1;
Break;
Default value:;
}
m++; //Collect the next data
}
Voidtimer 1 (void) interrupt 3//Timer 1 interrupt service.
{
th 1 = Hbeef;
TL 1 = Lbeef;
Beef = ~ beef;
}
/****************************************************/
/****************************************************/
/****************************************************/
This program is used when I debug the robot. There is a lot of code in it that you don't need. There is a built-in SPI for communicating with the wireless module, so you don't need to know about analog-to-digital conversion.
I hope you can find what you want.