Pesquisar neste blog

03/01/2021

Proteção contra curto - circuito: Exercícios Resolvidos

Lista de atividades: Proteção

1) Dimensionamento do dispositivo de proteção contra curto-circuito para o motor trifásico de 5cv de alimentação (fase-fase) de 220V, fator de potência igual a 0,7. O rendimento do motor é de 0,6. A relação IP/IN = 5. O tempo de partida é 5 segundos. 

Determinar a corrente nominal e a corrente de partida dada pela Equação 1.1







Resolução:





2) Dimensionamento do dispositivo de proteção contra curto-circuito para o motor trifásico de 14cv de alimentação (fase-fase) de 380V, fator de potência igual a 0,9. O rendimento do motor é de 0,85. A relação IP/IN = 6. O tempo de partida é 5 segundos.

Determinar a corrente nominal e a corrente de partida dada pela Equação 1.2

 





Resolução:





3) Dimensionamento do dispositivo de proteção contra curto-circuito para o motor trifásico de 50 cv de alimentação (fase-fase) de 380V, fator de potência igual a 0,92. O rendimento do motor é de 0,85. A relação IP/IN = 6. O tempo de partida é 7 segundos.

 Determinar a corrente nominal e a corrente de partida dada pela Equação 1.3








Resolução:











































4)  Dimensionamento do dispositivo de proteção contra curto-circuito para o motor trifásico de 30 cv de alimentação (fase-fase) de 380V, fator de potência igual a 0,92. O rendimento do motor é de 0,85. A relação IP/IN = 7. O tempo de partida é 6 segundos.

Determinar a corrente nominal e a corrente de partida dada pela Equação 1.4

 






Resolução:









Dimensionamento de condutores pelo método da queda de tensão

Um motor indução trifásico de 20 cv com alimentação em 220V, 60 Hz, fator de potência 0,8 e rendimento 0,96. A corrente de partida é cinco vezes a nominal. Está instalado a cerca a 50 metros do CCM. A queda de tensão desejada é de 2%.

Resolução:

Cálculo da corrente nominal:

In = ( Potencia mecanica . 736 ) / ( 3 . V . cos(θ) . n ) = 20 . 736/(3 . 220 . 0,8 . 0,96)= 50,3 [A]

Seção = 100.√3.ρ .Σ.L.I / (μ .V) 

ρ= (1/56); 
L= 50m(distância); 
In= 50,3 A;
μ= 2%(quedade tensão);
V= 220V (tensão) 

Seção = 100.√3.(1/56) . 50 . 50,3 / (2 . 220) = 17,67mm² ( comercial de 25 mm²)

Jogo do Flappy Bird com HTML

Arquivo: flappy.css
* {
    box-sizingborder-box;
}

@font-face{
    font-family'Pixel';
    srcurl('../fonts/Pixel.ttf');/*importando fonte*/
}

[wm-flappy]{
    positionrelative;/*posição relativa*/
    border5px solid dodgerblue;/*borda 5 pixel*/
    height700px;
    width1200px;
    margin15px;/*margem*/
    background-colordarkslateblue/*cor */
    overflowhidden/*qualquer item fora definida nessa div não vai aparecer*/
}

.passaro{
    positionabsolute;
    width60px;
    leftcalc(50% - 30px); /*50% à esquerda menos 30 pixel*/
}

.par-de-barreiras {
    positionabsolute;
    top0;
    height100%;
    displayflex;
    flex-directioncolumn;/*organiza na vertical*/
    justify-contentspace-between/*um embaixo , outro em cima, ...*/
}

.barreira {
    displayflex;
    flex-directioncolumn;
    align-itemscenter;
}

.barreira .borda {
    height30px;
    width130px/*largura*/
    backgroundlinear-gradient(90deg#639301#A5E82E);
    border2px solid #000;
}

.barreira .corpo { /*corpo*/
    height150px;
    width110px;
    backgroundlinear-gradient(90deg#639301#A5E82E);
    border-left2px solid #000;
    border-right2px solid #000;
}

.progresso {
    positionabsolute;
    top10px/*no topo*/
    right10px/*alinhado 10 pixel a esquerdad*/
    font-family: Pixel;
    font-size70px;
    z-index100;
}


Arquivo: flappy.js
function novoElemento(tagNameclassName) {
    const elem = document.createElement(tagName)
    elem.className = className
    return elem
}

function Barreira(reversa = false) {
    this.elemento = novoElemento('div''barreira')

    const borda = novoElemento('div''borda')
    const corpo = novoElemento('div''corpo')
    this.elemento.appendChild(reversa ? corpo : borda)
    this.elemento.appendChild(reversa ? borda : corpo)

    this.setAltura = altura => corpo.style.height = `${altura}px`
}

// const b = new Barreira(true)
// b.setAltura(300)
// document.querySelector('[wm-flappy]').appendChild(b.elemento)

function ParDeBarreiras(alturaaberturax) {
    this.elemento = novoElemento('div''par-de-barreiras')

    this.superior = new Barreira(true)
    this.inferior = new Barreira(false)

    this.elemento.appendChild(this.superior.elemento)
    this.elemento.appendChild(this.inferior.elemento)

    this.sortearAbertura = () => {
        const alturaSuperior = Math.random() * (altura - abertura)
        const alturaInferior = altura - abertura - alturaSuperior
        this.superior.setAltura(alturaSuperior)
        this.inferior.setAltura(alturaInferior)
    }

    this.getX = () => parseInt(this.elemento.style.left.split('px')[0])
    this.setX = x => this.elemento.style.left = `${x}px`
    this.getLargura = () => this.elemento.clientWidth

    this.sortearAbertura()
    this.setX(x)
}

// const b = new ParDeBarreiras(700, 200, 800)
// document.querySelector('[wm-flappy]').appendChild(b.elemento)

function Barreiras(alturalarguraaberturaespaconotificarPonto) {
    this.pares = [
        new ParDeBarreiras(alturaaberturalargura),
        new ParDeBarreiras(alturaaberturalargura + espaco),
        new ParDeBarreiras(alturaaberturalargura + espaco * 2),
        new ParDeBarreiras(alturaaberturalargura + espaco * 3)
    ]

    const deslocamento = 3
    this.animar = () => {
        this.pares.forEach(par => {
            par.setX(par.getX() - deslocamento)

            // quando o elemento sair da área do jogo
            if (par.getX() < -par.getLargura()) {
                par.setX(par.getX() + espaco * this.pares.length)
                par.sortearAbertura()
            }

            const meio = largura / 2
            const cruzouOMeio = par.getX() + deslocamento >= meio
                && par.getX() < meio
            if(cruzouOMeionotificarPonto()
        })
    }
}

function Passaro(alturaJogo) {
    let voando = false

    this.elemento = novoElemento('img''passaro')
    this.elemento.src = 'imgs/passaro.png'

    this.getY = () => parseInt(this.elemento.style.bottom.split('px')[0])
    this.setY = y => this.elemento.style.bottom = `${y}px`

    window.onkeydown = e => voando = true
    window.onkeyup = e => voando = false

    this.animar = () => {
        const novoY = this.getY() + (voando ? 8 : -5)
        const alturaMaxima = alturaJogo - this.elemento.clientHeight

        if (novoY <= 0) {
            this.setY(0)
        } else if (novoY >= alturaMaxima) {
            this.setY(alturaMaxima)
        } else {
            this.setY(novoY)
        }
    }

    this.setY(alturaJogo / 2)
}



function Progresso() {
    this.elemento = novoElemento('span''progresso')
    this.atualizarPontos = pontos => {
        this.elemento.innerHTML = pontos
    }
    this.atualizarPontos(0)
}

// const barreiras = new Barreiras(700, 1200, 200, 400)
// const passaro = new Passaro(700)
// const areaDoJogo = document.querySelector('[wm-flappy]')
// areaDoJogo.appendChild(passaro.elemento)
// areaDoJogo.appendChild(new Progresso().elemento)
// barreiras.pares.forEach(par => areaDoJogo.appendChild(par.elemento))
// setInterval(() => {
//     barreiras.animar()
//     passaro.animar()
// }, 20)

function estaoSobrepostos(elementoAelementoB) {
    const a = elementoA.getBoundingClientRect()
    const b = elementoB.getBoundingClientRect()

    const horizontal = a.left + a.width >= b.left
        && b.left + b.width >= a.left
    const vertical = a.top + a.height >= b.top
        && b.top + b.height >= a.top
    return horizontal && vertical
}

function colidiu(passarobarreiras) {
    let colidiu = false
    barreiras.pares.forEach(parDeBarreiras => {
        if (!colidiu) {
            const superior = parDeBarreiras.superior.elemento
            const inferior = parDeBarreiras.inferior.elemento
            colidiu = estaoSobrepostos(passaro.elementosuperior)
                || estaoSobrepostos(passaro.elementoinferior)
        }
    })
    return colidiu
}

function FlappyBird() {
    let pontos = 0

    const areaDoJogo = document.querySelector('[wm-flappy]')
    const altura = areaDoJogo.clientHeight
    const largura = areaDoJogo.clientWidth

    const progresso = new Progresso()
    const barreiras = new Barreiras(alturalargura200400,
        () => progresso.atualizarPontos(++pontos))
    const passaro = new Passaro(altura)

    areaDoJogo.appendChild(progresso.elemento)
    areaDoJogo.appendChild(passaro.elemento)
    barreiras.pares.forEach(par => areaDoJogo.appendChild(par.elemento))

    this.start = () => {//inicia o jogo
        // loop do jogo
        const temporizador = setInterval(() => {
            barreiras.animar()
            passaro.animar()

            if (colidiu(passarobarreiras)) {
                clearInterval(temporizador)
            }
        }, 20)
    }
}

new FlappyBird().start()


Arquivo: flappy.html
<!DOCTYPE html>
<html>

<head>
    <meta charset="UTF-8">
    <title>Flappy Bird</title>
    <link rel="stylesheet" href="css/estilo.css">
    <link rel="stylesheet" href="css/flappy.css">
</head>

<body class="conteudo">
    <h1>Flappy Bird</h1>
    <div wm-flappy></div>
    <script src="flappy.js"></script>
</body>

</html>





























Créditos para: Nilson Leitão










01/01/2021

Triângulo das potências - Exercícios Resolvidos

1) Encontre as potências faltantes no triângulo de potência.

a) 














Resolução:









b)













Resolução:












2) Calcule as potências ativas e reativas de um motor, sabendo que o fator de potência é igual 0,78. A potência Aparente é de 3KVA.

Resolução:



3) Determine a potência Aparante e Reativa de um motor, sabendo que o seu fator de potência é igual 0,85 e sua 1,47kW.

Resolução:


5) Sabendo que um motor de 5 cv e rendimento 70%, tem fator de potência 0,85. Determine as potências aparente, ativa e reativa do motor.

Resolução:


6) Sabendo que um motor de 12 cv e rendimento 85%, tem fator de potência 0,92, Determine as potências aparente, ativa e reativa do motor.

Resolução:



















31/12/2020

Projeto saldo de conta bancária em Linguagem MIPS Assembly

# PROJETO DO GERENCIADOR DE DEPÓSITOS E SAQUES

.data # diretiva de dados
sal: .asciiz "Informe o sado Inicial: "
menu: .asciiz "\n### MENU ###\n1 - Mostrar o saldo\n2 - Depositar\n3 - Efeturar o saque\n0 - Sair\nOpção: "
outsal: .asciiz "SALDO = "
outdep: .asciiz "Seu NOVO SALDO após o Depósito é: "
outdep2: .asciiz "Informe seu Depósito: "
outsaq: .asciiz "Seu NOVO SALDO após o Saque é: "
outsaq2: .asciiz "Informe seu Saque: "
out: .asciiz "Sistema Finalizado!\n"

.text # Diretiva de texto
.globl main # Diretiva global
main: # bloco main
li $v0, 4 # Imprimi uma string
la $a0, sal # Carrega sal no registrador a0
syscall
li $v0, 5 # le um número inteiro
syscall # Executa
move $t0, $v0 # Salva o número digitado em t0

rep: # bloco rep
li $v0, 4 # Imprimi uma string
la $a0, menu # Carrega o menu no registrador a0
syscall # executa
li $v0, 5 # le um numero inteiro
syscall
move $t1, $v0 # salv ao número digitado em t1
beq $t1, 0, sair # se t0 for 0, executa o bloco sair
jal opmenu # chama a função opmenu
j rep # cria o laço chamando rep

opmenu: # bloco menu
beq $t1, 1, saldo # se t1 for igual a 1, executa saldo
beq $t1, 2, deposito # se t1 for igual a 2, executado deposito
beq $t1, 3, saque # se t1 for igual a 3, execta saque

saldo: # bloco saldo
li $v0, 4 # Imprimi uma string
la $a0, outsal # Carrega outsal no registrador a0
syscall
li $v0, 1 # Imprimi um inteiro
move $a0, $t0 # Carrega a0 com o registrador t0
syscall
jr $ra # Volta para que o chamou (ja1)

deposito: # bloco deposito
li $v0, 4 # Imprimi uma string
la $a0, outdep2 # Carrega outdep2 no registrador a0
syscall
li $v0, 5 # le um número inteiro
syscall
move $t2, $v0 # Salva o número digitado em t2
add $t0, $t0, $t2 # SOMA t0 = t0 + t2
li $v0, 4 # Imprimi uma string
la $a0, outdep # Carrega otdep no registrador a0
syscall
li $v0, 1
move $a0, $t0 # Carrega o registrador a0 com t0
syscall
jr $ra # volta para que o chamou (ja1)

saque:
li $v0, 4 # Imprimi uma string
la $a0, outsaq2 # Carrega outdsaq2 no registrador a0
syscall
li $v0, 5 # le um número inteiro
syscall
move $t4, $v0 # Salva o número digitado em t4
sub $t0, $t0, $t4 # SUBTRAI t0 = t0 - t4
li $v0, 4 # Imprimi uma string
la $a0, outsaq # Carrega otdep no registrador a0
syscall
li $v0, 1
move $a0, $t0 # Carrega o registrador a0 com t0
syscall
jr $ra # volta para que o chamou

sair: # bloco sair
li $v0, 4
la $a0, out
syscall
li $v0, 10 # Sair do programa
syscall

Simulador: MARS 4.5


Calculadora em linguagem MIPS Assembly

.data
menu: .asciiz "***** MENU *****\n1 - Somar\n2 - Subtrair\n3 - Multiplicar\n4 - Dividir\n0 - SAIR\nOpção: "
n1: .asciiz "Entre com o primeiro número: "
n2: .asciiz "Entre com o segundo número: "
r: .asciiz "Resultado = "
pula: .asciiz "\n\n"

.macro pula_linha # Macro pula linha
li $v0, 4
la $a0, pula # Carrega a string de pula em $a0
li $v0, 4
la $a0, pula
syscall
.end_macro

.macro menu
li $v0, 4
la $a0, menu
syscall
li $v0, 5 # Prepara para ler um número inteiro
syscall
move $t0, $v0 # Salva o número digitado em $t0
.end_macro

.text # Diretiva de dados
.globl principal # Diretiva global

principal: # Função principal
menu # Chama a macro menu
# Condições
beq $t0, 1, somar # se $t0 for digitado 1 vai para o bloco somar
# Bloco somar
beq $t0, 2, subtrair
# bloco subtrair
beq $t0, 3, multiplicar
# bloco multiplicar
beq $t0, 4, dividir

beq $t0, 0, sair
# bloco sair

somar:
# pede o primeiro número
li $v0, 4
la $a0, n1 # Carrega n1 no registrador $a0
syscall
li $v0, 5
syscall
move $t1, $v0 
# pede o segundo número
li $v0, 4
la $a0, n2 # Carregga n2 no registrador
syscall
li $v0, 5
syscall
move $t2, $v0 # Salva o número digitado
add $t3, $t1 $t2 # SOMA: $t3 = t1 + t2
# Mostra o resultado na tela
li $v0, 4
la $a0, r # Carrega r no registrador $a0
syscall
li $v0, 1 # Imprimi m número
la $a0, ($t3) # Carrega o inteiro de $t3 em $a0
syscall
pula_linha # Executa a macro
j principal # Executa o bloco principal

subtrair: # Bloco subtrair
# pede o primeiro número
li $v0, 4 # Imprimi uma string
la $a0, n1 # Carrega n1 no registrador a0
syscall
li $v0, 5 # Lê um número inteiro
syscall
move $t1, $v0 # Salva o número digitado em $t1
# pede o segundo número
li $v0, 4 # Imprimir uma string
la $a0, n2 # Carrega n2 no registrador
syscall
li $v0, 5
syscall
move $t2, $v0 # Salva o número digitado em $t2
sub $t3, $t1, $t2 # SUBTRAI: t3 = t1 - t2
#MOSTRA o resultado na tela
li $v0, 4 # Imprimi uma string
la $a0, r # Carrega no registrador a0
syscall
li $v0, 1 # Imprimi um número
la $a0, ($t3) # Carrega o inteiro 
syscall
pula_linha # Executa a macro pula linha
j principal # Executa o bloco principal

multiplicar: # Bloco multiplicar:
# Pede o primeiro número
li $v0, 4 # Imprimi uma string
la $a0, n1 # Carrega n1 no registrador 
syscall
li $v0, 5 # Le um número inteiro
syscall
la $a0, ($t3) # Carrega o inteiro 
# Pede o segundo número
move $t1, $v0 # Salva o número digitado em $t1
la $a0, n2 # Carrega n2 no registrador 
syscall
li $v0, 5 # Lê um número inteiro
syscall
move $t2, $v0 # Salva o número digitado em $t2
mul $t3, $t1, $t2 # MULTIPLICA: t3 = t1 * t2
#Mostra o resultado na tela
li $v0, 4 # Imprimi uma string
la $a0, r # Carrega r no registrador $a0
syscall
li $v0, 1 # Imprimi um número inteiro
la $a0, ($t3) # Carrega o número inteiro de $t3 em $a0
syscall # Executa
pula_linha # Executa a macro pula_linha
j principal # Executa o bloco principal

dividir: # bloco dividir
# Pede o primeiro número
li $v0, 4 # Imprimi uma string
la $a0, n1 # Carrega n1 no registrador $a0
syscall
li $v0, 5 # Lê um número inteiro
syscall
move $t1, $v0 # Salva o número digitado em t1
# pede o segundo número
li $v0, 4 # Imprimi uma string
la $a0, n2 # Carrega n2 no registrador $a0
syscall
li $v0, 5 # Le um número inteiro
syscall
move $t2, $v0 # Salva o número digitado em t2
div $t3, $t1, $t2 # DIVIDE: t3 = t1 / t2
# Mostra o resultado
li $v0, 4 # Imprimi uma string
la $a0, r # Carrega no registrador a0
syscall
li $v0, 1 # Imprimi uma string
la $a0, ($t3) # Carrega um inteiro em a0
syscall
pula_linha
j principal
# bloco para sair
sair:
li $v0, 10
syscall



Simulador: MARS 4.5


23/12/2020

Número positivo ou negativo com loop em MIPS Assembly

Faca um programa que solicita do usuário um número inteiro. O programa deverá dizer se este número é positivo ou negativo se for zero.

Resolução:

.data
msgpositivo: .asciiz "Este número é positivo\n"
msgnegativo: .asciiz "Este número é negativo\n"
msg1: .asciiz "Digite um número: "
fim: .asciiz "Fim do programa!\n"
.text
li $v0 ,4 # prepara o registrador
la $a0, msg1 # a0 = msg1
syscall
li $v0, 5 # recebe um número inteiro
syscall
move $t0, $v0 # t0 = v0
beq $t0, $a0,sair #se t0 == 0, vai sair
jal verifica # vai para verificação

verifica: # função de verificação
bgt $t0, $0, maior # se t0 > 0, vai para maior
blt $t0, $a0, menor # se t0 < 0, vai para menor

maior:
li $v0, 4
la $a0, msgpositivo # a0 = msgpositivo
syscall
j sair # bloco de codigo, vai para sair

menor:
li $v0, 4
la $a0, msgnegativo # a0 = msgnegativo
syscall
j sair

sair: # bloco para sair
li $v0, 4 # imprime uma string
la $a0, fim # a0 = fim
syscall
li $v0, 10
syscall

Simulador: MARS 4.5


Condicional if em Linguagem MIPS Assembly

Faça um programa em MIPS Assembly que receba uma idade e identifique se ele é maior ou de menor idade.

Resolução:

.data
pergunta: .asciiz "Digite a sua idade: "
msg1: .asciiz "Você é menor de idade"
msg2: .asciiz "Você é maior de idade"

.text
li $v0, 4 # imprimir uma string
la $a0, pergunta # a0 = pergunta
syscall # Executar
li $v0, 5 # Faz a leitura de um número inteiro
syscall # Executa
move $t1, $v0 # t1 = v0
li $t0, 18 # t0 = 18
blt $t1, $t0, menor # Desvie se $t1 for menor do que 18 para o bloco menor
bge $t1, $t0, maior # Devie se $t1 for maior ou igual a 18 para o bloco maior

menor: 
li $v0, 4 # Imprimi uma string
la $a0, msg1 # a0 = msg1
syscall
li $v0, 10 # Finaliza o programa

maior:
li $v0, 4
la $a0, msg2 # a0 = msg2
syscall
li $v0, 10
syscall

Simulador: MARS 4.5


22/12/2020

Fração em linguagem MIPS Assembly

.data
x: .asciiz "Digie o valor de X: "
y: .asciiz "Digite o valor de Y: "
z: .asciiz "O resultado de X/Y = "
.text
li $v0, 4 # imprime uma string
la $a0, x # a0 = x
syscall # Executa
li $v0, 5 # Recebe um numero inteiro
syscall
move $t1, $v0 # t1 = v0
li $v0, 4
la $a0, y # a0 = y
syscall
li $v0, 5 # Imprime uma string
syscall
move $t2, $v0 # t2 = v0
div $t3, $t1, $t2 # t3 = t1/t2
li $v0, 4 #imprime um númeor inteiro
la $a0, z # a0 = z
syscall # executa
li $v0, 1 # Imprime um número inteiro
la $a0, ($t3) # a0 = t3
syscall
li $v0, 10 # prepara para finalizar
syscall

Simulador MARS 4.5


Cubo de um número usando MIPS Assebly

.data
numero: .asciiz "Digite um número: "
cubo: .asciiz "O cubo é = "
.text
li $v0, 4 # Imprimi uma string
la $a0, numero # a0 = numero
syscall # executa
li $v0, 5 # eitura de um número inteiro
syscall
move $t1, $v0 # t1 = v0
mul $t2, $t1, $t1 # t2 = t1 * t1
mul $t3, $t1, $t2 # t3 = t1 * t2
li $v0, 4 # imprimi uma string
la $a0, cubo # a0 = cubo
syscall
li $v0, 1 # imprime um número inteiro
la $a0, ($t3) # a0 = t3
syscall
li $v0, 10 # Finalizar o programa
syscall

Simulador MARS 4.5


20/12/2020

Corrida de São Silvestre em Linguagem Assembly

Construa um programa para ser colocado no relógio que utiliza um recurso GPS que ao ser pressionado um botão aparece no display quantos quilômetros já foram percorridos. A posição da largada sabendo que o percurso da corrida possui 15 Km, o display também deverá calcular quantos Km falta para concluir a corrida.

Resolução:

.data
kp: .asciiz "Digite o Km percorrido: "
kf: .asciiz "Km finais = "

.text
li $v0, 4 # imprimir uma string
la $a0, kp # a0 = kp
syscall # Execute
li $v0, 5 # Ler um número inteiro
syscall # Executa
move $t0, $v0 # t0 = v0
li $t1, 15 # t1 = 15
sub $t2, $t1, $t0 # t2 = t1 - t0

li $v0, 4 # Imprima uma string
la $a0, kf # a0 = kf
syscall
li $v0, 1
la $a0, ($t2) #a0 = t2
syscall # Executa


Soma com MIPS usando Linguagem Assembly

Soma de 2 números com leitura em MIPS Assembly.

Resolução:

.data
num1: .asciiz "Digite o primeiro numero: "
num2: .asciiz "Digite o segundo numero: "
Resultado: .asciiz "Soma = "
.text
li $v0, 4
la $a0, num1
syscall

li $v0, 5
syscall
move $t0, $v0

li $v0, 4
la $a0, num2
syscall

li $v0, 5
syscall
move $t1, $v0

#tendo os dois valores 
add $t2, $t1, $t0
li $v0, 4
la $a0, Resultado
syscall

li $v0, 4
la $a0, Resultado
syscall

li $v0, 1
move $a0, $t2
syscall


Simulador: MARS 4.5






19/12/2020

Olá Mundo no MARS em Linguagem MIPS Assembly #03

.data # diretiva data

.macro finalizarprograma
li $v0, 10 # prepara o programa para finalizar programa
syscall # executa
.end_macro

.macro printf(%str)
.data
# o conteúdo dessa variável mensagem será enviada por essa função print
msg: .asciiz %str # recebe uma string de fora
.text
li $v0, 4 # prepara o registrador para receber (imprimir) uma string
la $a0, msg # envia essa string para o registrador
syscall # executa executa
.end_macro # diretiva de finalização macro

.text
.globl principal

principal:
# será executada dentro da diretiva global
printf("Olá Mundo!\n") #chama a macro e passa uma string
finalizarprograma



Olá Mundo no MARS em Linguagem MIPS Assembly #02

# 2° exemplo com diretiva global
.data
msg: .ascii "Olá Mundo!"

.text
.globl principal # diretiva global

principal:
li $v0, 4 # prepara para receber uma string (v0 = 4
la $a0, msg # a0 = msg
syscall # executa
li $v0, 10 # finaliza o programa

Simulador MARS 4.5


Olá Mundo no MARS em linguagem MIPS Assembly #01

.data #faz as variáveis
msg: .asciiz "Ola Mundo!" #asciiz = tipo de variável
.text #diretiva de texto

#instrução para o registrador
li $v0, 4 #prepara o registrador para imprimir uma string
# a0 = msg
la $a0, msg #la = leitura do endereço de memória onde está o texto e inserir dentro do registrador a0
syscall #executa o procedimento
li $v0, 10 #prepara o processador para finalizar
syscall