test_lcd.lss
来自「在WinAVR下的ST7565圖形點陣的驅動程序」· LSS 代码 · 共 1,839 行 · 第 1/5 页
LSS
1,839 行
d6c: 85 e5 ldi r24, 0x55 ; 85
d6e: 8d b9 out 0x0d, r24 ; 13
SPSR = 0x00;
d70: 1e b8 out 0x0e, r1 ; 14
}
d72: 08 95 ret
00000d74 <spi_write>:
//功能:使用SPI发送一个字节
void spi_write(uint8 sData)
{
d74: 8f b9 out 0x0f, r24 ; 15
//SPSR &= ~BIT(SPIF);
SPDR = sData;
while(!(SPSR & BIT(SPIF)));
d76: 77 9b sbis 0x0e, 7 ; 14
d78: fe cf rjmp .-4 ; 0xd76 <spi_write+0x2>
//sData=SPDR;//读从机发回来的数据
}
d7a: 08 95 ret
00000d7c <spi_read>:
//功能:使用SPI接收一个字节
uint8 spi_read(void)
{
d7c: 8f ef ldi r24, 0xFF ; 255
d7e: 8f b9 out 0x0f, r24 ; 15
SPDR = 0xFF;
while(!(SPSR & BIT(SPIF)));
d80: 77 9b sbis 0x0e, 7 ; 14
d82: fe cf rjmp .-4 ; 0xd80 <spi_read+0x4>
return SPDR;
d84: 8f b1 in r24, 0x0f ; 15
}
d86: 08 95 ret
00000d88 <twi_SetBitrate>:
********************************************************************/
uint8 Twi_SLA;
void twi_SetBitrate(uint16 bitrateKHz)
{
d88: bc 01 movw r22, r24
/* set i2c bitrate*/
/* SCL freq = F_CPU / (16 + 2 * TWBR)) */
/* for processors with additional bitrate division (mega64) */
/* SCL freq = F_CPU/(16+2*TWBR*4^TWPS) */
/* set TWPS to zero */
TWSR = 0x00;
d8a: 10 92 71 00 sts 0x0071, r1
/* calculate bitrate division */
bitrate_div = ((F_CPU / 1000) / bitrateKHz);
d8e: 8c ec ldi r24, 0xCC ; 204
d90: 9c e1 ldi r25, 0x1C ; 28
d92: 0e 94 29 09 call 0x1252 ; 0x1252 <__udivmodhi4>
if(bitrate_div >= 16) bitrate_div = (bitrate_div - 16) / 2;
d96: 60 31 cpi r22, 0x10 ; 16
d98: 30 f0 brcs .+12 ; 0xda6 <twi_SetBitrate+0x1e>
d9a: 86 2f mov r24, r22
d9c: 90 e0 ldi r25, 0x00 ; 0
d9e: 40 97 sbiw r24, 0x10 ; 16
da0: 95 95 asr r25
da2: 87 95 ror r24
da4: 68 2f mov r22, r24
TWBR = bitrate_div;
da6: 60 93 70 00 sts 0x0070, r22
}
daa: 08 95 ret
00000dac <twi_init>:
//TWI初始化函数
// SCL freq = 100KHz
void twi_init(void)
{
dac: 0f 93 push r16
dae: 1f 93 push r17
TWCR = 0x00; // 禁止TWI
db0: 04 e7 ldi r16, 0x74 ; 116
db2: 10 e0 ldi r17, 0x00 ; 0
db4: f8 01 movw r30, r16
db6: 10 82 st Z, r1
twi_SetBitrate(100);
db8: 84 e6 ldi r24, 0x64 ; 100
dba: 90 e0 ldi r25, 0x00 ; 0
dbc: 0e 94 c4 06 call 0xd88 ; 0xd88 <twi_SetBitrate>
TWCR = BIT(TWEN); // 启动TWI | BIT(TWSTA)
dc0: 84 e0 ldi r24, 0x04 ; 4
dc2: f8 01 movw r30, r16
dc4: 80 83 st Z, r24
}
dc6: 1f 91 pop r17
dc8: 0f 91 pop r16
dca: 08 95 ret
00000dcc <twi_start>:
//仲裁成为主机,发送START信号
//返回值: 0表示成功, 1表示失败
uint8 twi_start(void)
{
dcc: 84 ea ldi r24, 0xA4 ; 164
dce: 80 93 74 00 sts 0x0074, r24
TWCR = BIT(TWINT) | BIT(TWEN) | BIT(TWSTA);
while(!(TWCR & BIT(TWINT)));
dd2: 80 91 74 00 lds r24, 0x0074
dd6: 87 ff sbrs r24, 7
dd8: fc cf rjmp .-8 ; 0xdd2 <twi_start+0x6>
if((TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
dda: 80 91 71 00 lds r24, 0x0071
dde: 88 7f andi r24, 0xF8 ; 248
de0: 88 30 cpi r24, 0x08 ; 8
de2: 11 f4 brne .+4 ; 0xde8 <twi_start+0x1c>
de4: 90 e0 ldi r25, 0x00 ; 0
de6: 07 c0 rjmp .+14 ; 0xdf6 <twi_start+0x2a>
de8: 80 91 71 00 lds r24, 0x0071
dec: 90 e0 ldi r25, 0x00 ; 0
dee: 88 7f andi r24, 0xF8 ; 248
df0: 80 31 cpi r24, 0x10 ; 16
df2: 09 f0 breq .+2 ; 0xdf6 <twi_start+0x2a>
df4: 91 e0 ldi r25, 0x01 ; 1
return TW_ERROR;
return TW_OK;
}
df6: 89 2f mov r24, r25
df8: 08 95 ret
00000dfa <twi_stop>:
//停止通信,发送STOP信号
void twi_stop(void)
{
dfa: 84 e9 ldi r24, 0x94 ; 148
dfc: 80 93 74 00 sts 0x0074, r24
TWCR = BIT(TWINT) | BIT(TWEN) | BIT(TWSTO);
while(!(TWCR & BIT(TWSTO)));
e00: 80 91 74 00 lds r24, 0x0074
e04: 84 ff sbrs r24, 4
e06: fc cf rjmp .-8 ; 0xe00 <twi_stop+0x6>
}
e08: 08 95 ret
00000e0a <twi_to_write>:
//发出从机地址与写命令,即SLA+W,进入MT模式
//返回值: 0表示成功, 1表示失败
uint8 twi_to_write(void)
{
e0a: 80 91 22 01 lds r24, 0x0122
e0e: 8e 7f andi r24, 0xFE ; 254
e10: 80 93 73 00 sts 0x0073, r24
TWDR = Twi_SLA & 0xFE;
TWCR = BIT(TWINT) | BIT(TWEN);
e14: 84 e8 ldi r24, 0x84 ; 132
e16: 80 93 74 00 sts 0x0074, r24
while(!(TWCR & BIT(TWINT)));
e1a: 80 91 74 00 lds r24, 0x0074
e1e: 87 ff sbrs r24, 7
e20: fc cf rjmp .-8 ; 0xe1a <twi_to_write+0x10>
if(TW_STATUS != TW_MT_SLA_ACK)
e22: 80 91 71 00 lds r24, 0x0071
e26: 90 e0 ldi r25, 0x00 ; 0
e28: 88 7f andi r24, 0xF8 ; 248
e2a: 88 31 cpi r24, 0x18 ; 24
e2c: 09 f0 breq .+2 ; 0xe30 <twi_to_write+0x26>
e2e: 91 e0 ldi r25, 0x01 ; 1
return TW_ERROR;
return TW_OK;
}
e30: 89 2f mov r24, r25
e32: 08 95 ret
00000e34 <twi_to_read>:
//发出从机地址与读命令,即SLA+R,进入MR模式
//返回值: 0表示成功, 1表示失败
uint8 twi_to_read(void)
{
e34: 80 91 22 01 lds r24, 0x0122
e38: 81 60 ori r24, 0x01 ; 1
e3a: 80 93 73 00 sts 0x0073, r24
TWDR = Twi_SLA | 0x01;
TWCR = BIT(TWINT) | BIT(TWEN);
e3e: 84 e8 ldi r24, 0x84 ; 132
e40: 80 93 74 00 sts 0x0074, r24
while(!(TWCR & BIT(TWINT)));
e44: 80 91 74 00 lds r24, 0x0074
e48: 87 ff sbrs r24, 7
e4a: fc cf rjmp .-8 ; 0xe44 <twi_to_read+0x10>
if(TW_STATUS != TW_MR_SLA_ACK)
e4c: 80 91 71 00 lds r24, 0x0071
e50: 90 e0 ldi r25, 0x00 ; 0
e52: 88 7f andi r24, 0xF8 ; 248
e54: 80 34 cpi r24, 0x40 ; 64
e56: 09 f0 breq .+2 ; 0xe5a <twi_to_read+0x26>
e58: 91 e0 ldi r25, 0x01 ; 1
return TW_ERROR;
return TW_OK;
}
e5a: 89 2f mov r24, r25
e5c: 08 95 ret
00000e5e <twi_send>:
//向从机发数据
//返回值: 0表示接到ACK, 1表示失败, 2表示接NOT ACK
uint8 twi_send(uint8 data)
{
e5e: 80 93 73 00 sts 0x0073, r24
TWDR = data;
TWCR = BIT(TWINT) | BIT(TWEN);
e62: 84 e8 ldi r24, 0x84 ; 132
e64: 80 93 74 00 sts 0x0074, r24
while(!(TWCR & BIT(TWINT)));
e68: 80 91 74 00 lds r24, 0x0074
e6c: 87 ff sbrs r24, 7
e6e: fc cf rjmp .-8 ; 0xe68 <twi_send+0xa>
if(TW_STATUS == TW_MT_DATA_ACK)
e70: 80 91 71 00 lds r24, 0x0071
e74: 88 7f andi r24, 0xF8 ; 248
e76: 88 32 cpi r24, 0x28 ; 40
e78: 11 f4 brne .+4 ; 0xe7e <twi_send+0x20>
e7a: 80 e0 ldi r24, 0x00 ; 0
e7c: 08 95 ret
return TW_OK;
else if(TW_STATUS == TW_MT_DATA_NACK)
e7e: 80 91 71 00 lds r24, 0x0071
e82: 88 7f andi r24, 0xF8 ; 248
e84: 80 33 cpi r24, 0x30 ; 48
e86: 11 f0 breq .+4 ; 0xe8c <twi_send+0x2e>
e88: 81 e0 ldi r24, 0x01 ; 1
e8a: 08 95 ret
e8c: 82 e0 ldi r24, 0x02 ; 2
return TW_NACK;
return TW_ERROR;
}
e8e: 08 95 ret
00000e90 <twi_receive>:
//接收从机发来的数据
//返回值: 0表示接到ACK, 1表示失败, 2表示接NOT ACK
uint8 twi_receive(uint8 *data)
{
e90: fc 01 movw r30, r24
TWCR = BIT(TWINT)| BIT(TWEN);
e92: 84 e8 ldi r24, 0x84 ; 132
e94: 80 93 74 00 sts 0x0074, r24
while(!(TWCR & BIT(TWINT)));
e98: 80 91 74 00 lds r24, 0x0074
e9c: 87 ff sbrs r24, 7
e9e: fc cf rjmp .-8 ; 0xe98 <twi_receive+0x8>
*data = TWDR;
ea0: 80 91 73 00 lds r24, 0x0073
ea4: 80 83 st Z, r24
if(TW_STATUS == TW_MR_DATA_ACK)
ea6: 80 91 71 00 lds r24, 0x0071
eaa: 88 7f andi r24, 0xF8 ; 248
eac: 80 35 cpi r24, 0x50 ; 80
eae: 11 f4 brne .+4 ; 0xeb4 <twi_receive+0x24>
eb0: 80 e0 ldi r24, 0x00 ; 0
eb2: 08 95 ret
return TW_OK;
else if(TW_STATUS == TW_MR_DATA_NACK)
eb4: 80 91 71 00 lds r24, 0x0071
eb8: 88 7f andi r24, 0xF8 ; 248
eba: 88 35 cpi r24, 0x58 ; 88
ebc: 11 f0 breq .+4 ; 0xec2 <twi_receive+0x32>
ebe: 81 e0 ldi r24, 0x01 ; 1
ec0: 08 95 ret
ec2: 82 e0 ldi r24, 0x02 ; 2
return TW_NACK;
return TW_ERROR;
}
ec4: 08 95 ret
00000ec6 <twi_SendAck>:
//接收从机发来的数据
//返回值: 0表示接到ACK, 1表示失败, 2表示接NOT ACK
uint8 twi_SendAck(uint8 Ack)
{
ec6: 88 23 and r24, r24
ec8: 11 f0 breq .+4 ; 0xece <twi_SendAck+0x8>
if(Ack)
{
TWCR = BIT(TWINT)| BIT(TWEN) | BIT(TWEA);
eca: 84 ec ldi r24, 0xC4 ; 196
ecc: 01 c0 rjmp .+2 ; 0xed0 <twi_SendAck+0xa>
}
else
{
TWCR = BIT(TWINT)| BIT(TWEN);
ece: 84 e8 ldi r24, 0x84 ; 132
ed0: 80 93 74 00 sts 0x0074, r24
}
while(!(TWCR & BIT(TWINT)));
ed4: 80 91 74 00 lds r24, 0x0074
ed8: 87 ff sbrs r24, 7
eda: fc cf rjmp .-8 ; 0xed4 <twi_SendAck+0xe>
if(TW_STATUS == TW_MR_DATA_ACK)
edc: 80 91 71 00 lds r24, 0x0071
ee0: 88 7f andi r24, 0xF8 ; 248
ee2: 80 35 cpi r24, 0x50 ; 80
ee4: 11 f4 brne .+4 ; 0xeea <twi_SendAck+0x24>
ee6: 80 e0 ldi r24, 0x00 ; 0
ee8: 08 95 ret
return TW_OK;
else if(TW_STATUS == TW_MR_DATA_NACK)
eea: 80 91 71 00 lds r24, 0x0071
eee: 88 7f andi r24, 0xF8 ; 248
ef0: 88 35 cpi r24, 0x58 ; 88
ef2: 11 f0 breq .+4 ; 0xef8 <twi_SendAck+0x32>
ef4: 81 e0 ldi r24, 0x01 ; 1
ef6: 08 95 ret
ef8: 82 e0 ldi r24, 0x02 ; 2
return TW_NACK;
return TW_ERROR;
}
efa: 08 95 ret
00000efc <twi_WriteBuffer>:
uint8 twi_WriteBuffer(uint8 SubAddr, uint8 *Buff, uint8 cnt, uint8 MemType)
{
efc: 98 2f mov r25, r24
efe: 52 2f mov r21, r18
//仲裁成为主机,发送START信号
//返回值: 0表示成功, 1表示失败
uint8 twi_start(void)
{
TWCR = BIT(TWINT) | BIT(TWEN) | BIT(TWSTA);
f00: 84 ea ldi r24, 0xA4 ; 164
f02: 80 93 74 00 sts 0x0074, r24
while(!(TWCR & BIT(TWINT)));
f06: 80 91 74 00 lds r24, 0x0074
f0a: 87 ff sbrs r24, 7
f0c: fc cf rjmp .-8 ; 0xf06 <twi_WriteBuffer+0xa>
if((TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
f0e: 80 91 71 00 lds r24, 0x0071
f12: 88 7f andi r24, 0xF8 ; 248
f14: 88 30 cpi r24, 0x08 ; 8
f16: 11 f0 breq .+4 ; 0xf1c <twi_WriteBuffer+0x20>
f18: 80 91 71 00 lds r24, 0x0071
//发出从机地址与写命令,即SLA+W,进入MT模式
//返回值: 0表示成功, 1表示失败
uint8 twi_to_write(void)
{
TWDR = Twi_SLA & 0xFE;
f1c: 80 91 22 01 lds r24, 0x0122
f20: 8e 7f andi r24, 0xFE ; 254
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?