ZX-BATTLE
COMPUTADOR ZX SPECTRUM
Emuladores
Jogos
Programação
Sites
Utilitários
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
LINKS
 
Inicio Site
 
 

COMPUTADOR - ZX SPECTRUM


TUTORIAIS



"Como Ligar o ZX Spectrum ao Raspberry PI3"

    - Parte 1 de 10 - Hardware Necessário para o Projecto.- Ver
    - Parte 2 de 10 - Instalação do S.O. do Raspberry PI3. - Ver
    - Parte 3 de 10 - Instalação de alguns utilitários necessários.- Ver
    - Parte 4 de 10 - Teste da Conexão entre Raspberry e ZX Spectrum.- Ver


- Parte 5 de 10 - Apresentação dos Programas utilizados no Projecto.

     Nesta parte do Tutorial vamos aprofundar mais os detalhes da programação do ZX Spectrum. Todas as rotinas que executam funções com grande rigor na temporização têm que ser colocadas na memória RAM Alta. A memória Alta é utilizada exclusivamente pela CPU e está localizada a partir do endereço 32768 até ao 65535. No nosso  programa vamos colocar na memória Alta, as rotinas de Envio/Recepção de Dados através da Porta RS232. Optamos por colocar essas Rotinas no endereço 65436, ocupando apenas os últimos 100 bytes da memória RAM do ZX Spectrum. 

     Nas transferências de dados entre o ZX Spectrum e o Raspberry não vamos usar o controle de fluxo por hardware, porque o Raspberry não tem os sinais RTS/CTS. A solução que arranjamos foi usar um protocolo de software que não precisa desses sinais. Vamos utilizar um sistema de Pacotes de Dados de tamanho variável, para evitar erros na transmissão/recepção. Vejamos a estrutura dum Pacote de Dados:

#Bytes Funcao
==============================
2      Tamanho Pacote menos 2
1      Flag
n      Dados
1      CRC
==============================

     Os dois primeiros bytes indicam o tamanho do bloco de dados. O byte seguinte, chamado FLAG é usado para identificar o bloco de dados. Depois vêem os Dados propriamente ditos e que podem ter o tamanho que quisermos sem ultrapassar o limite de 64K. Por último temos o byte de controle CRC, este byte fecha o Bloco de dados. Observe o seguinte exemplo, vamos enviar a letra "A", com o código ASCII 65 e a FLAG 128, fica assim.

==============================
  3 - Tamanho Bloco Dados
  0 - Tamanho Bloco Dados

128 - Flag
 65 - Dados

193 - CRC

    O byte CRC é obtido realizando a operação Lógica XOR entre os bytes do Bloco, excluindo o Tamanho. Vamos fazer o calculo em binário para se perceber melhor.

Binário    Decimal
==============================
Entrada:

10000000   128
01000001   65

Saida (CRC):

11000001   193

    A função lógica XOR dá um valor lógico "1" na saida se os dois bits de entrada forem diferentes, caso contrário dá "0". No nosso protocolo de comunicação o Raspberry desempenha o papel de Servidor e o ZX Spectrum de Cliente. Cabe ao Spectrum iniciar a comunicação e ao Raspberry responder ao comando solicitado.

     O Interface 1 usa três Portos de Entrada/Saída para controlar o Hardware.

=========================================================
  - Porto 247 - Leitura/Escrita de Dados na Porta
                RS232 ou na Rede.

  - Porto 239 - Estado e Controle de vários Sinais.

  - Porto 231 - Leitura/Escrita de Dados na Microdrive.
=========================================================

Vejamos a descrição dos mesmos.

=========================================================
Porto 247 (RS232/NETWORK DATA) - Leitura
=========================================================
Bits:

B0 --> NETWORK INPUT
B1 --- x
B2 --- x
B3 --- x
B4 --- x
B5 --- x
B6 --- x
B7 --> RS232 RX DATA

=========================================================
Porto 247 (RS232/NETWORK DATA) - Escrita
=========================================================
Bits:

B0 <-- NETWORK OUTPUT / RS232 TX DATA
B1 --- x
B2 --- x
B3 --- x
B4 --- x
B5 --- x
B6 --- x
B7 --- x

=========================================================
Porto 239 (STATUS/CONTROL) - Leitura
=========================================================
Bits:

B0 --> WR PROTECT
B1 --> SYNC
B2 --> GAP
B3 --> CTS
B4 --> BUSY
B5 --- x
B6 --- x
B7 --- x

=========================================================
Porto 239 (STATUS/CONTROL) - Escrita
=========================================================
Bits:

B0 <-- COMMS OUT = 0 NETWORK OUTPUT
                 = 1 RS232 OUTPUT
B1 <-- COMMS CLK
B2 <-- R/W
B3 <-- ERASE
B4 <-- RTS
B5 <-- WAIT
B6 --- x
B7 --- x

=========================================================
Porto 231 (MICRODRIVE R/W)
=========================================================

     Para ler os dados da Porta RS232 utilizamos o Porto 247 e verificamos o estado do Bit 7. O circuito electrónico responsável por gerir as tensões eléctricas nos pinos da ficha RS232 não inverte os niveis eléctricos, assim se o Bit 7 for zero, significa que o sinal RXD está a -15v, caso contrário  a tensão é de +15v. O mesmo acontece com o sinal TXD. Vamos apresentar o primeiro programa para o ZX Spectrum, responsável pelo carregamento do nosso Sistema Operativo. Este programa Abre, Carrega e Executa o ficheiro "ZX-SOS" que está localizado no Raspberry.


;================================================
;Programa de arranque do Sistema ZX-SOS V1.4
;
;Linguagem:
;
;ASM Z80 (Compilador AZ80)
;
;Computador:
;
;ZX Spectrum 48K c/ Interface 1
;
;Actualização:
;
;2023-06-25
;
;(C) por Jorge Pedro Soares
;================================================
;Constantes usadas no programa.

if1_rwdat  equ 247   ;Porto Leitura/Escrita Dados
if1_ctrl   equ 239   ;Porto de Controle
if1_mdrv   equ 231   ;Porto da MicroDrive

rx_chk     equ 128   ;Mascara para Sinal RXD

baud       equ 20    ;9600 bauds

rs_in_rot  equ 65436 ;Rotina de recepção de dados
rs_out_rot equ 65486 ;Rotina de envio de dados


org 23818 ;O programa começa neste endereço

di
ld   hl,rs_in_48K ;Copia as rotinas da
ld   de,rs_in_rot ;porta rs232 para o
ld   bc,100       ;topo da memoria RAM!
ldir
;------------------------------------------------
;Selecciona a Porta RS232 e coloca a linha RTS
;em repouso!

ld   a,239        ;Em binário é 11101111
out  (if1_ctrl),a ;Porto de Controle

;Coloca também a linha TXD em repouso.

xor  a             ;Faz Reg. A=0
out  (if1_rwdat),a ;Porto de Entrada/Saida Dados

;------------------------------------------------
;Envia o Comando OPEN_ZXFILE, neste caso
;abre o ficheiro "ZX-SOS".

ld   hl,Cmd_OPEN_ZXFILE  ;Bloco de dados do
                         ;Comando OPEN_ZXFILE

call Send_Block ;Envia Bloco de dados ao Raspberry

ld   hl,Buf_RX ;Buffer para colocar os dados recebidos.

call Recv_Block ;Recebe Bloco de dados do Raspbrry

;Recebe a resposta do Raspberry. Todos os ficheiros
;para o ZX Spectrum têm que ter um Bloco Inicial chamado
;"BOOT_BLOCK" de 12 bytes, com os caracteres "ZXFILE" e
;com o endereço onde vai ser carregado o proximo bloco.

jr   nz,error ;Termina o programa se ocorreu erro!

;A resposta só é válida se for recebido o
;"BOOT_BLOCK", indicado pela FLAG com código "128".

ld   a,b       ;O Reg.A contem o valor da FLAG. Se for
cp   128       ;128 é um ficheiro para o Spectrum.
jr   z,Main2

;Para os outros valores é indicado erro
;assinalado pelo piscar da margem do ecrã.

Error:

ei

Error2:

ld   a,r
and  7
out  (254),a

halt

jr   Error2

;Continua neste ponto se tudo estiver OK.

main2:

;Carrega o segundo bloco (PROGRAM_BLK),
;no endereço RAM indicado pelo BOOT_BLK.

;Envia o comando LD_BLK ao Raspberry.
;Recebe como resposta o Bloco de dados
;a seguir ao BOOT_BLK.

ld   hl,Cmd_LD_BLK ;Comando LD_BLK
call Send_Block    ;Envia ao Raspberry

;Como resposta o Raspberry envia o PROGRAM_BLK.

ld   hl,(ADDR_LD);Endereço da RAM para o PROGRAM_BLK.
push hl
call Recv_Block ;Recebe Bloco de dados do Raspbrry

pop  hl        ;Recupera valor de HL.

jr   nz,error  ;se ZF=0 Salta para ERROR.

jp   (hl)      ;Salta para o endereço de
               ;execução do PROGRAMA.
;------------------------------------------------
;Rotinas
;------------------------------------------------
;Esta rotina é usada para sincronizar a comunicação
;entre o ZX spectrum e o Raspberry, basicamente
;consiste no seguinte, o Spectrum envia os caracteres
;"ZX" ao Raspberry e aguarda que o Raspberry os devolva.
;Este procedimento é executado sempre pelo ZX Spectrum
;antes de enviar um Comando.

rs_sync:

ld   a,90 ;Letra "Z"
ld   c,a  ;C="Z"

rs_sync2:

ld   a,c
call rs_out ;Envia a letra "Z" ao Raspberry.

call rs_in  ;Aguarda a resposta do Raspberry.

cp   c      ;Se for a letra "Z" continua.

jr   nz,rs_sync2 ;Senão repete de novo.

;Envia a letra "X" e fica a aguardar
;que o Rspberry reenvie a mesma letra.

ld   a,88   ;Letra "X"
ld   b,a    ;B="X"
call rs_out ;Envia Letra "X"

rs_sync3:

;Fica num ciclo a ler os bytes da Porta
;RS232. Só são aceites as letras "Z" e "X",
;outros valores reiniciam a rotina!

call rs_in
cp   c           ;Se for a letra "Z" continua
                 ;a ler a Porta RS232.

jr   z,rs_sync3

cp   b           ;Termina a rotina se for
                 ;detectada a letra "X"

jr   nz,rs_sync  ;Senão Reenicia o Procedimento.
ret
;------------------------------------------------
;Esta rotina lê un bloco de dados para o
;endereço indicado em HL.

recv_block:

;HL tem o endereço da RAM onde vamos colocar
;os dados recebidos.

call rs_in ;Lê 1 byte da Porta RS232
ld   e,a   ;1º byte do tamanho do bloco.

call rs_in ;Lê outro byte da Porta RS232
ld   d,a   ;2º byte do tamanho do bloco.

dec  de    ;Ajusta o Tamanho do Bloco porque
           ;vamos receber ainda a FLAG_BLK
           ;que já faz parte do Bloco de Dados.

;DE Contém o tamanho do bloco menos 1.

call rs_in ;Lê a FLAG_BLK da Porta RS232
ld   c,a   ;Inicializa o CRC c/ FLAG_BLK
ld   b,a   ;Guarda FLAG_BLK no Reg.B

;A detecçao de erros é feita em
;tempo real, sendo assim quando
;terminar a transferência de dados
;a Flag Z deve apresentar o valor 1
;para ter sucesso.

;Entramos agora num ciclo que Lê o numero
;de bytes indicados em DE e coloca-os no
;endereço apontado por HL.

recv_data:

call rs_in

ld   (hl),a

xor  c   ;Calcula o CRC!
ld   c,a ;Guarda-o no regist C!
inc  hl
dec  de
ld   a,d
or   e
jr   nz,recv_data

ld   a,c ;CRC
or   a   ;Z=1 OK / Z=0 Erro!
ret
;------------------------------------------------
Send_block:

call rs_sync ;Sincroniza a Comunicação.

ld   e,(hl)  ;Carrega DE com o tamanho do Bloco.
inc  hl
ld   d,(hl)

dec  hl

inc  de  ;Ajusta Tamanho Bloco pois vamos
inc  de  ;enviar mais 2 bytes.

Send_data:

ld   a,(hl)
call rs_out
inc  hl
dec  de
ld   a,d
or   e
jr   nz,Send_data
ret
;================================================
;Esta rotina controla a cor da margem enquanto
;recebe um byte, coloca primeiro a magem em azul
;e depois de receber um byte coloca-a em preto.

rs_in:

ld a,1
out (254),a

call rs_in_rot

ex af,af'
xor a
out (254),a
ex af,af'
ret
;------------------------------------------------
;Esta rotina faz o mesmo que a anterior, só que
;coloca primeiro a magem em vermelho e depois de
;enviar um byte coloca-a em preto.


rs_out:

ex af,af'
ld a,2
out (254),a
ex af,af'

call rs_out_rot

xor a
out (254),a
ret

;==============================================================
;Actualizaçao:
;
;2023-04-20
;2023-04-06
;2022-10-16
;
;(C) Jorge P. Soares

;Rotinas RS232 para ZX Spectrum 48K - Interface 1

;BAUD Constantes
;
;19200 -> 273,182
;9600 -> 364T,546T -> E=20
;4800 -> 729T,1093T -> E=43
;2400 -> 1458T,2187T -> E=88
;
;==============================================================
rs_in_48K:

exx
ld   c,if1_rwdat
ld   d,rx_chk
ld   l,128    ;Em binário é 10000000. O Bit 7 vai ser usado como
              ;marcador, quando chegar ao BIT 0 passa
              ;depois para a CF provocando o Termino da ROIINA

ld   e,baud   ;Constante de Temporização

rs_start:

in a,(c)      ;Lê linha RXD

and d         ;Verifica Bit 7,

jr z,rs_start ;Se for zero repete

;Após a detecção do START BIT espera 1,5 BAUDS
;antes de ler a linha RXD.

;As instrucoes a seguir calculam a constante
;BAUD * 1,5 + 1 necessaria para a temporizaçao inicial.

ld   a,e     ;E = Constante de Temporizaçao.
rra          ;
add  a,e     ;
add  a,1     ;
ld   d,a     ;D = E * 1,5 + 1
;------------------------------------------------
;Aguarda 1,5 BAUDS antes de ler a porta RS232.

rs_loop:

dec  d
jr   nz,rs_loop ;Ciclo de temporização.
;------------------------------------------------
and  a     ;
ld   d,e   ;E = Proximas Temporizações
           ;são de 1 BAUD.

in   h,(c) ;Lê linha RXD.
;------------------------------------------------
rlc  h     ;Coloca BIT 7 do Reg. H na CF.
rr   l     ;Coloca CF no BIT 7 do Reg. L. Ao mesmo
           ;tempo move o BIT 0 para a CF.

jr   nc,rs_loop ;Repete o ciclo enquanto a CF=0
;
;------------------------------------------------
srl  e     ;Calcula Baud/2

rs_stop:

dec  e
jr   nz,rs_stop ;Temporização Final de 1/2 BAUD

ld   a,l ;A = L = Byte Recebido.
cpl      ;Inverte os Bits para cumprir a norna RS232.
exx      
ret      ;Termina a rotina no inicio do STOP BIT
         ;para dar tempo a receber o proximo Byte. 

rs_inx:

dx 8,0   ;Sem importancia, só para ajustar o tamanho
         ;das duas rotinas para 100 Bytes.
;==============================================================
rs_out_48K:
;==============================================================
exx ;Usa os registos alternativos para ser mais rapido.


cpl         ;Inverte os bits de acordo
            ;com o Protocolo RS232.
 
ld   h,a    ;A = Byte para Enviar.
ld   e,baud ;E = Velocidade de Transmissão.

;No Total vamos enviar 10 bits:
;
; - 1 START BIT
; - 8 BITS DADOS
; - 1 STOP BIT

ld   l,10        ;L = Contador de Bits
ld   a,1         ;A = Linha TX ligada para START BIT
ld   c,if1_rwdat ;C = Porto de Envio de dados

rs_out2:
;--------------------------------------------------------------
out (c),a        ;Coloca linha TX no estado indicado
                 ;no registo A

ld   d,e         ;E = Constante de Temporizaçao

rs_out3:

dec  d
jr   nz,rs_out3  ;Ciclo de Temporizaçao

xor  a           ;Limpa A
rr   h           ;H contém Byte a Enviar, Coloca Bit 0 de H
                 ;na Flag C e Limpa Bit 7

rla              ;Roda a Flag C para o Bit 0 do Reg. A para
                 ;controlar sinal TXD. 

dec  l           ;
jr   nz,rs_out2  ;Repete o Ciclo até L=0

exx              ;
ret              ;

rs_outx:
;------------------------------------------------------------------------------
;Dados
;--------------------------------------
Buf_RX:

DX 6,0

ADDR_LD:

DX 8,0

;--------------------------------------
Cmd_OPEN_ZXFILE:

DB 9   ;Tamanho BLOCO 11-2=9
DB 0

DB 4   ;Cmd_OPEN_ZXFILE

DB "Z" ;Nome "ZX-SOS"
DB "X"
DB "-"
DB "S"
DB "O"
DB "S"
DB 10

DB 110 ;CRC
;------------------------------------------------
Cmd_LD_BLK:

db 2 ;LEN
db 0

db 32 ;Cmd_LD_BLK
db 32 ;CRC
;------------------------------------------------
;eof

    Este é o programa que vamos usar para iniciar o sistema operativo ZX-SOS. O código ASM mostrado produz 274 bytes de dados. Vamos usar um truque que consiste em colocar este código dentro dum programa BASIC. Normalmente o Programa BASIC do ZX Spectrum 48K é carregado no endereço 23755, mas quando se liga o Interface  1 o sistema altera esse endereço para 23813. Podemos saber qual é o valor actual, escrevendo o seguinte programa BASIC:

PRINT PEEK 23635+256*PEEK 23636

    Quando que se liga o ZX Spectrum com o Interface 1 conectado, ainda é apresentado o endereço 23755, só depois de usar um dos comando concebidos para o Interface é que o Sistema muda o dito endereço. Como tinhamos dito no parágrafo anterior, vamos colocar o código ASM dentro do programa BASIC, para isso criamos uma linha com o comando REM com 300 caracteres, depois é só fazer LOAD "" CODE e gravar o programa normalmente. Não podemos esquecer-nos de digitar por exemplo o comando "CAT 1" antes de carregar o código ASM, para o ZX Spectrum mudar o endereço do BASIC. Veja a imagem 5.1 para ter uma ideia dum programa BASIC para essa função.

zx

    Para obter o Código Máquina, escrevemos com um editor de texto no Windows/Ms-Dos o programa que mostramos neste tutorial e gravamos com o nome "sos48k.asm". Todos os programas ASM apresentados neste tutorial devem ser compilados com o nosso utilitario "AZ80". Este utilitário é muito prático e funciona em vários Sistemas Operativos da MicroSoft, só possui uma limitação, não usa nomes grandes para Ficheiros/Directorios. Para o nosso exemplo use a seguinte linha de comandos no PC:

AZ80.COM -all -cod sos48k sos48k > log.txt

    Abra o ficheiro "log.txt" para obter mais informações sobre o ficheiro que acabamos de compilar. Este utilitário cria um ficheiro "TAP" pronto a ser carregado pelo ZX Spectrum. Para quem não quiser ter esse trabalho todo pode descarregar os ficheiros (TXT,ASM,AZ80,TAP e WAV).

Programa SOS48K - download

Notas importantes sobre as Microdrives.

    À semelhança do que se passa com o Raspberry em relação às letras maiúsculas, nas Microdrives também acontece o mesmo, assim ao gravar ou carregar um programa temos que ter atenção ao nome do mesmo, não podemos trocar as maiúscula por minúsculas pois vai dar erro. Por exemplo "Teste" é diferente de "teste". O melhor mesmo é gravar tudo em minúsculas para não haver confusão.

    Como já é do conhecimento dos utilizadores do Spectrum, existe a opção de execução automática dos programas BASIC. Para usar essa opção temos que colocar a função LINE à frente do SAVE, como indicado a seguir.

SAVE "programa" LINE 10 

    O Sistema da Microdrive acrescentou mais uma facilidade, trata-se do carregamento automático dum programa que esteja na Microdrive. Para isso acontecer o programa tem que chamar-se "run" e ter sido gravado com a função LINE. Para executa-lo basta escrever no Spectrum "run" e carregar em "ENTER", o programa arranca imediatamente. Esta função só está activa se o Spectrum acabou de ser ligado ou se foi executado o comando "NEW". Para concluir, depois  de carregar o programa a partir duma Cassete com o comando MERGE "", grave-o numa Microdrive com o comando:

SAVE *"m";1;"run" LINE 10

    Assim sempre que precisar de carregar o nosso Sistema Operativo, só tem que premir as teclas "RUN" e "ENTER" do ZX Spectrum.

    Para o Raspberry escrevemos o programa em Python3 que mostramos a seguir. O programa é uma versão de teste. Pode editá-lo com o utilitário NANO como mostramos num tutorial anterior ou pode fazer o download no link que vamos indicar mais à frente. Alertamos para os cuidados a ter ao escrevermos o programa, devemos respeitar escrupulosamente o espaçamento do texto, basta colocar um espaço a mais ou a menos para provocar erro na execução do programa. É uma boa prática usar multiplos de 4 espaços para alinhar o código (0, 4, 8, 12, 16, etc). Segue o programa:

# ---------------------------------------
# Programa RPI3SERVER Versão 1.1

# Linguagem: PYTHON3
#
# Este programa implementa os COMANDOS:
#
# OPEN_ZXFILE
# LD_BLK
# DIR
#
# Actualizações:
#
# 2023-04-11
# 2023-04-09
# 2023-04-08
# (C) by Jorge P. Soares
# ----------------------------------------
import os
import serial
import time

rs = serial.Serial("/dev/ttyAMA0", 9600)
path = "./FTP/files/"
fflag = 0
print("Sistema Online!")
rs.write([170])

# CODE 1

while True:

    rst = 0
    old = 0
    new = 0

    while (rst == 0):
        old = new
        rxd = rs.read(1)
        rs.write(rxd)
        new = int.from_bytes(rxd, "little")

        print(rxd)

        if new == 88 and old == 90:
            print("Codigo Detectado!")
            rst = 1
        else:
            print("Lixo!")

    print("Aguardando Ordens!")
    rxd = rs.read(2)
    rxsz = 256 * rxd[1]+rxd[0]
    print("Recebendo ", rxsz," Bytes")
    rxd = rs.read(rxsz)
    crc = 0
    print("Verificando CRC.")
    for i in range(0, rxsz):
        crc = crc ^ (rxd[i])
    print("CRC = ",crc)
    if crc == 0:

        print("Descodificando Comandos.")
        cmd = rxd[0]

        if cmd == 2:

            # Lista os ficheiros do directorio ZX
            print("Comando DIR.")
            zx_dir = []
            files = os.listdir(path)

            for f in files:

                zx_dir.append(f+"\n")

            n_files = len(zx_dir)
            print("Numero de Ficheiros:",n_files)
            txd = [0,0,2,n_files]

            for i in range(n_files):

                fn_bytes = bytes (zx_dir[i], 'utf-8')

                for n in range(len(fn_bytes)):

                    txd.append(fn_bytes[n])

            crc = 0

            print("Calculando CRC dos dados a Enviar!")

            for m in range(2, len(txd)):

                crc = crc ^ (txd[m])

            txd.append(crc)
            txsz = len (txd)
            txsz2 = txsz -2
            txszb = txsz2.to_bytes(2,"little")
            txd [0] = txszb [0]
            txd [1] = txszb [1]
            print("Enviando dados para o ZX!")
            rs.write(txd)

        elif cmd == 32:

            print("Lendo Bloco de Dados!")
            rdd = f.read(2)
            rdsz = 256 * rdd[1] + rdd[0]
            rdd2 = f.read(rdsz)
            rs.write(rdd)
            rs.write(rdd2)

        elif cmd == 4:

            print("Abrindo Ficheiro para Execucao!")
            fn = rxd[1:rxsz - 2]
            fn2 = "".join(map(chr,fn))

            try:

                print("Lendo Ficheiro Indicado!")
                f = open(path + fn2,"rb")
                rdd = f.read(12)
                rdsz = 256 * rdd[1] + rdd[0]
                print(rdsz)
                id1 = "ZXFILE"
                id2 = "".join(map(chr, rdd[3:9]))
                print("Abrir Ficheiro:",fn2)
                if rdsz == 10 and id1 == id2:
                    rs.write(rdd)
                    print("BOOT Block enviado!")
                    fflag = 1

                else:

                    print("Bad File!")
                    txd = [2, 0,66,66]
                    rs.write(txd)
                    f.close()
                    fflag = 0

            except FileNotFoundError:

                txd = [2,0,65,65]
                rs.write(txd)
                print("O Ficheiro nao existe!")

        else:

            print("Comando Invalido")

    else:

        print("Deu Merda!")
        break
# --------------------------------------------------------
# eof
# --------------------------------------------------------

Programa RPI3SERVER - download

    Vamos agora instalar e configurar um Cliente FTP para podermos enviar os ficheiros (jogos e programas) para o Raspberry. Já instalámos num artigo anterior um servidor FTP no Raspberry, chegou o momento de usá-lo. Podemos utilizar vários equipamentos para comunicar com o Servidor FTP, optámos por um Telemóvel Android. Vamos instalar um Cliente FTP chamado "AndFTP" no nosso Telemóvel. Observe as imagens seguintes para acompanhar o processo.

    Vamos pesquisar no Play Store a aplicação "andftp".

zx


    Da lista que aparece, seleccionamos a aplicação "andftp (your ftp client)".

zx


    Clicamos no icon da aplicação para avançar!

zx


    Carregamos em instalar para prosseguir!

zx


    Abrimos a aplicação e clicamos no botão "+" para adicionarmos o Servidor do Raspberry!

zx


    Introduzimos os dados pedidos na imagem e clicamos em guardar, os valores podem ser outros, depende das configurações de cada Raspberry!

zx


Atribuimos um nome ao Servidor que acabámos de criar!

zx


    E pronto já está configurado o Cliente FTP. Sempre que precisarmos de enviar ficheiros para o Raspberry é só abrir a aplicação e clicar no icon do Servidor!

zx



    Este ecrã mostra os Ficheiros/Directorios do Raspberry, seleccionamos o directorio "files", para colocarmos os ficheiros do nosso projecto. Clique no icon que representa o Telemóvel no topo do ecrã, para escolhermos os ficheiros que vamos enviar para o Raspberry.

zx


    Neste ecrã temos acesso aos Ficheiro/Directorios do Telemóvel, clicamos no directorio onde estão os ficheiros que queremos enviar para o Raspberry (upload).

zx


    Por fim seleccionamos os ficheiros que queremos enviar e clicamos na seta que aponta para cima. Esta seta indica que vamos enviar os ficheiros para o computador remoto Raspberry, esta operação chama-se upload. Quando a seta aponta para baixo significa download. Para mudar dum modo para o outro (upload/download) clicamos no icon do despositivo (Telemóvel ou Nuvem) que está no topo do ecrã.

zx

    Podemos usar também um Cliente FTP para o Computador Pessoal. Um dos mais utilizádos é o "FileZilla" e é grátis. O FileZilla permite fazer as transferências mais facilmente entre os dois computadores. Essa facilidade é devida ao facto de o FileZilla mostrar simultaneamente os ficheiros  do computador local e os do computador remoto. Assim é só clicarmos nos ficheiros duma janela para transferir para a outra. A janela da esquerda mostra os ficheiros do computador local e a da direita os do computador remoto. Para fazer o upload clicamos num ficheiro da janela da esquerda e para o download clicamos num ficheiro da janela da direita.

    Observe a Fig.5.13 para perceber como configurar o FileZilla, resumidamente os dados são os mesmos que foram usados com o "AndFTP".

zx

Programa Cliente FTP FileZilla para Windows XP - download

    Para terminar esta parte do tutorial vamos criar no Telemóvel/Tablet ou Computador Pessoal um Directorio chamado "_RPI3", é nele que vamos colocar os ficheiros que queremos enviar para o Raspberry. Vamos copiar o ficheiro rpi3server.py para esse directrorio. Com o Cliente FTP vamos enviar agora esse ficheiro para o Raspberry. Para ser mais fácil de usar o programa rpi3server temos que copiá-lo para o directorio do Python3 que é o "home", para faze-lo digite o seguinte comando no Putty:

cp FTP/files/rpi3server.py rpi3server.py

    O comando "cp" abreviatura de "copy" copia o ficheiro rpi3server.py do directorio FTP/files para o directorio "home". Para executar o programa digite:

python3 rpi3server.py

    Descarregue alguns jogos da nossa lista e transfira-os para o Raspberry com o Cliente FTP (Atenção temos que descompacta-los com o WinRAR antes de envia-los ). Execute os dois programas "rpi3server.py" no Raspberry e "sos48k-boot" no ZX Spectrum. Se tudo estive bem podemos começar a usar o programa do ZX Spectrum. O sistema ZX-SOS tem os seguintes comandos implementados:

    - DIR - Mostra os ficheiros existentes  no Raspberry.
    - CLS - Limpa Ecrã.

    Para executar um Programa/Jogo basta digitar o nome mostrado pelo comando DIR. Para sair dum Jogo é necessário desligar ou fazer o Reset do ZX Spectrum, depois basta premir "RUN" e "ENTER" para voltar ao Sistema ZX-SOS.

    Chegamos ao fim de mais um tutorial, no próximo vamos abordar o ZX Spectrum  128K, +2 e +3.

    Até à Próxima.

Anterior     Seguinte






P
U
B
L
I
C
I
D
A
D
E
Copyright 2005-2023 ZX-Battle. Todos os direitos Reservados