Alejandra_A1b_Maquinas_Eletricas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Alejandra_A1b_Maquinas_Eletricas.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3.8.9 64-bit"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.9",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "interpreter": {
      "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/HenriqueMAP/electrical-induction-motor/blob/main/Alejandra_A1b_Maquinas_Eletricas.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y_yK4vCiuNfB"
      },
      "source": [
        "## Atividade A1b - Máquinas Elétricas\n",
        "\n",
        "### Enunciado\n",
        "\n",
        "> Um motor de indução trifásico ligado em Y, de seis polos, tensão de linha de 460Volts, potência ativa de 20kW e frequência de 60Hz, tem os seguintes valores de parâmetros, referidos ao estator:\n",
        "\n",
        "*   R1 = 0,271 Ohms;\n",
        "*   R2 = 0,188 Ohms;\n",
        "\n",
        "*   X1 = 1,12 Ohms;\n",
        "*   X2 = 1,91 Ohms;\n",
        "\n",
        "*   Xm = 23,10 Ohms;\n",
        "*   Escorregamento = 1,6%;\n",
        "\n",
        "#### Objetivos\n",
        "\n",
        ">Realize um código na linguagem de programação de sua preferência para calcular:\n",
        "\n",
        "*   1 - Velocidade;\n",
        "*   2 - Corrente do estator;\n",
        "*   3 - Fator de potência;\n",
        "*   4 - Corrente de rotor;\n",
        "*   5 - Conjugado de partida;\n",
        "*   6 - Conjugado máximo;\n",
        "*   7 - Escorregamento máximo;\n",
        "*   8 - Velocidade de ocorrência do escorregamento;\n",
        "\n",
        "##### Gráfico\n",
        "\n",
        "> Construa uma curva de Conjugado versus Velocidade.\n",
        ">\n",
        "> Considere que a variação de escorregamento está entre o intervalo de \"0 < s < 1\". Ou seja, considere o intervalo completo de variação de \"s\".\n",
        "\n",
        "### Formato de entrega\n",
        "\n",
        "> Realize um pequeno vídeo mostrando os seus resultados e poste no mural digital que está no seguinte link: https://padlet.com/victoriaalejandrafmu/lle1oyktf0nheqmr\n",
        "\n",
        "#### Datas\n",
        "\n",
        "> Solicitação: 20/09/2021\n",
        "> Prazo máximo de entrega: 04/10/2021\n",
        "\n",
        "---\n",
        "\n",
        "### Desenvolvido por Henrique Matheus Alves Pereira\n",
        "### R.A.: 8486961\n",
        "### Nono semestre de Engenharia Elétrica"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ByWZPFeSE_WR"
      },
      "source": [
        "## Importando as bibliotecas que serão utilizadas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B5cC03CIx8zP"
      },
      "source": [
        "#import cmath for complex number operations \n",
        "import cmath\n",
        "\n",
        "import math"
      ],
      "execution_count": 160,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ffbshd3Z9ewW"
      },
      "source": [
        "## Etapa 1: Cálculo da velocidade síncrona\n",
        "\n",
        "### Sub-etapa: Velocidade síncrona\n",
        "\n",
        "n_sinc = (120/p) * fse\n",
        "\n",
        "---\n",
        "\n",
        "### Sub-etapa: Velocidade mecânica\n",
        "\n",
        "n_m = (1 - s) * n_sinc\n",
        "\n",
        "---\n",
        "\n",
        "#### Grandezas elétricas:\n",
        "\n",
        "- fse = frequência de fase (Hz) | (Hertz)\n",
        "\n",
        "- n_m = velocidade do eixo do motor (rpm) | (rotações por minuto)\n",
        "\n",
        "- n_sinc = velocidade síncrona (rpm) | (rotações por minuto)\n",
        "\n",
        "- p = Quantidade de polos do motor (Adimensional)\n",
        "\n",
        "- s = escorregamento (%) | Porcentagem\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c-LgXbW1-rbN",
        "outputId": "e5e956a6-8554-4fba-aba2-726453c2ad8b"
      },
      "source": [
        "print(\"Etapa 1: Resultados\")\n",
        "\n",
        "n_sinc = (120/6) * 60\n",
        "print(\"\\nn_sinc - Velocidade síncrona = \" + str(n_sinc) + \" rpm\")\n",
        "\n",
        "n_m = (1-0.016) * n_sinc\n",
        "print(\"\\nn_m - Velocidade do eixo do motor = \" + str(n_m) + \" rpm\")"
      ],
      "execution_count": 161,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Etapa 1: Resultados\n",
            "\n",
            "n_sinc - Velocidade síncrona = 1200.0 rpm\n",
            "\n",
            "n_m - Velocidade do eixo do motor = 1180.8 rpm\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JGb2iBhWTlVd"
      },
      "source": [
        "## Estapa 2: Cálculo da corrente do estator\n",
        "\n",
        "![](https://github.com/HenriqueMAP/electrical-induction-motor/blob/main/Circuito-Equivalente.png?raw=true)\n",
        "\n",
        "### Sub-etapa: Impedância do estator\n",
        "\n",
        "Z1 = R1 + jX1\n",
        "\n",
        "> retorna um número complexo, ou seja, Z1 = (real + jImaginário). Em Python, é uma tupla.\n",
        "\n",
        "---\n",
        "\n",
        "### Sub-etapa: Impedância do rotor\n",
        "\n",
        "Z2 = (R2/s) + jX2\n",
        "\n",
        "> retorna um número complexo, ou seja, Z2 = (real + jImaginário). Em Python, é uma tupla.\n",
        "\n",
        "---\n",
        "\n",
        "### Sub-etapa: Impedância equivalente\n",
        "\n",
        "Zeq = (Z2/Xm) + Z1\n",
        "\n",
        "> retorna um número complexo, ou seja, Zeq = (real + jImaginário). Em Python, é uma tupla.\n",
        "\n",
        "\n",
        "\n",
        "> *Observação:\n",
        "> \n",
        "> Processamento 1 (Z2/Xm) = ((Z2 * Xm) / (Z2 + Xm))\n",
        ">\n",
        "> Processamento 2 (Z2/Xm) = ((Z2Polar * XmPolar) / (Z2Retangular + XmRetangular))\n",
        "> \n",
        "> Z2Polar e XmPolar = (módulo ∟ ângulo)\n",
        ">\n",
        "> Z2Retangular e XmRetangular = (real + jImaginário)\n",
        ">\n",
        "> Processamento 3 (Z2/Xm) = ((Z2MultXmPolar) / (Z2PlusXmRetangular))\n",
        "> \n",
        "> Processamento 4 (Z2/Xm) = ((Z2MultXmPolar) / (Z2PlusXmPolar))\n",
        ">\n",
        "> Processamento 5 Zeq = Z2DivXmPolar + Z1Retangular\n",
        ">\n",
        "> Processamento 6 Zeq = Z2DivXmRetangular + Z1Retangular\n",
        ">\n",
        "> Processamento 7 Zeq = (real + jImaginário)\n",
        "\n",
        "---\n",
        "\n",
        "### Sub-etapa: Tensão no estator\n",
        "\n",
        "V1 = I1 + Zeq\n",
        "\n",
        "---\n",
        "\n",
        "#### Grandezas elétricas:\n",
        "\n",
        "- I1 = Corrente no estator | (A) - Ampère\n",
        "\n",
        "- jX1 = Impedância em formato imaginário do estator | (Ω) - Ohms\n",
        "\n",
        "- jX2 = Impedância em formato imaginário do rotor | (Ω) - Ohms\n",
        "\n",
        "- R1 = Resistência do estator | (Ω) - Ohms\n",
        "\n",
        "- R2 = Resistência do rotor | (Ω) - Ohms\n",
        "\n",
        "- s = Escorregamento | (%) - Porcentagem\n",
        "\n",
        "- V1 = Tensão no estator | (V) - Volts\n",
        "\n",
        "- Z1 = Impedância do estator | (Ω) - Ohms\n",
        "\n",
        "- Z2 = Impedância do rotor | (Ω) - Ohms\n",
        "\n",
        "- Zeq = Impedância equivalente | (Ω) - Ohms\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RFDaGOjqGzAP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "cellView": "code",
        "outputId": "a1e5c3b8-ea93-4c2c-d028-16b529f83382"
      },
      "source": [
        "print(\"Etapa 2: Resultados\")\n",
        "\n",
        "R1 = 0.271\n",
        "X1 = 1.12\n",
        "R2 = 0.188\n",
        "X2 = 1.91\n",
        "Xm = 23.10\n",
        "s  = 0.016\n",
        "\n",
        "Z1 = complex(R1, X1)\n",
        "print(\"\\nZ1 = \" + str(Z1) + \" Ohms\")\n",
        "\n",
        "Z2 = complex((R2/s), X2)\n",
        "print(\"\\nZ2 = \" + str(Z2) + \" Ohms\")\n",
        "\n",
        "XmRectangular = complex(0, Xm)\n",
        "print(\"\\nXm rect = \" + str(XmRectangular))\n",
        "\n",
        "XmPolarTupla = cmath.polar(XmRectangular)\n",
        "\n",
        "# XmPolarArray - Separando a parte real da imaginária\n",
        "XmPolarArray = []\n",
        "XmPolarArray.append(XmPolarTupla[0])\n",
        "XmPolarArray.append(XmPolarTupla[1])\n",
        "\n",
        "print(\"\\nXmPolar = \" + str(XmPolarArray))\n",
        "\n",
        "RadToDegrees = (180 / cmath.pi)\n",
        "\n",
        "XmPolarArray[1] = XmPolarArray[1] * (RadToDegrees)\n",
        "\n",
        "# Z2Array - Separando a parte real da imaginária\n",
        "Z2Array = []\n",
        "Z2Array = str(Z2).split(\"+\")\n",
        "Z2Array[0] = Z2Array[0].replace(\"(\", \"\")\n",
        "Z2Array[1] = Z2Array[1].replace(\")\", \"\")\n",
        "print(\"\\nZ2Array * XmPolarArray = \" + str(float(Z2Array[0]) * XmPolarArray[0]))\n",
        "\n",
        "Z2PolarTupla = cmath.polar(Z2)\n",
        "\n",
        "# Z2PolarArray - Separando a parte do módulo do ângulo\n",
        "Z2PolarArray = []\n",
        "Z2PolarArray.append(Z2PolarTupla[0])\n",
        "Z2PolarArray.append(Z2PolarTupla[1])\n",
        "Z2PolarArray[1] = Z2PolarArray[1] * (RadToDegrees)\n",
        "print(\"\\nZ2PolarArray = \" + str(Z2PolarArray))\n",
        "\n",
        "# Montando um array com os valores processados do numerador da divisão\n",
        "Z2ParalellXm = [str(float(Z2PolarArray[0]) * XmPolarArray[0]), \" < \" ,\n",
        "                str(float(Z2PolarArray[1]) + XmPolarArray[1])]\n",
        "\n",
        "print(\"\\nZ2ParalellXm = \" + str(Z2ParalellXm))\n",
        "\n",
        "# Montando um array com os valores processados do denominador da divisão\n",
        "Z2ParalellXm.append(Z2Array[0])\n",
        "Z2ParalellXm.append(\"+\")\n",
        "Z2ParalellXm.append(float(Z2Array[1].replace(\"j\",\"\")) + float(str(Xm).replace(\"j\",\"\")))\n",
        "\n",
        "print(\"\\nZ2ParalellXm = \" + str(Z2ParalellXm))\n",
        "\n",
        "# Tranformando a parte real e imaginária do denominador da divisão em Polar\n",
        "Z2ParalellXmRadianos = cmath.polar(complex(float(Z2ParalellXm[3]), float(Z2ParalellXm[5])))\n",
        "\n",
        "print(\"\\nZ2ParalellXmRadianos = \" + str(Z2ParalellXmRadianos))\n",
        "\n",
        "# Convertendo o valor Polar do denominador da divisão de Radianos para Graus\n",
        "Z2ParalellXmDegrees = []\n",
        "Z2ParalellXmDegrees.append(Z2ParalellXmRadianos[0])\n",
        "Z2ParalellXmDegrees.append(Z2ParalellXmRadianos[1] * RadToDegrees)\n",
        "\n",
        "print(\"\\nZ2ParalellXmDegrees = \" + str(Z2ParalellXmDegrees))\n",
        "\n",
        "# Finalmente, calculando a divisão entre os valores em módulo do numerador e denominador da divisão\n",
        "# E como parte da divisão, ocorre a subtração entre os valores do numerador e denominador dos ângulos\n",
        "# O valor resultante dessa operação é um número Polar composto de módulo e ângulo\n",
        "Z2ParalellXmResult = []\n",
        "Z2ParalellXmResult.append(float(Z2ParalellXm[0]) / float(Z2ParalellXmDegrees[0]))\n",
        "Z2ParalellXmResult.append(float(Z2ParalellXm[2]) - float(Z2ParalellXmDegrees[1]))\n",
        "\n",
        "print(\"\\nZ2ParalellXmResult = \" + str(Z2ParalellXmResult))\n",
        "\n",
        "# Processo de conversão de valor Polar para Retangular do resultado da divisão do Z2 com o XM\n",
        "# Em Python, é difícil enxergar, porém para utilizar uma função trigonométrica, é necessário\n",
        "# Converter o valor de Graus para Radianos, calcular a função trigonométrica, e só depois\n",
        "# Converter o resultado da função trigonométrica em Graus. É o que ocorre abaixo.\n",
        "#\n",
        "# Ou seja, em Python, uma função trigonométrica sempre recebe um valor em radianos e retorna o resultado em radianos.\n",
        "ZeqRealRadianos = (float(Z2ParalellXmResult[0])*math.degrees(math.cos(math.radians(float(Z2ParalellXmResult[1])))))\n",
        "ZeqRealGraus = (ZeqRealRadianos / RadToDegrees)\n",
        "print(\"\\nZeqRealGraus = \" + str(ZeqRealGraus))\n",
        "\n",
        "# Aqui ocorre o mesmo processamento de funcão trigonométrica com os tipos de Radianos e Graus\n",
        "ZeqImaginarioRadianos = (float(Z2ParalellXmResult[0])*math.degrees(math.sin(math.radians(float(Z2ParalellXmResult[1])))))\n",
        "ZeqImaginarioGraus = (ZeqImaginarioRadianos / RadToDegrees)\n",
        "print(\"\\nZeqImaginarioGraus = \" + str(ZeqImaginarioGraus))\n",
        "\n",
        "# Aqui retorna o valor completo em Retangular\n",
        "ZeqRect = complex(ZeqRealGraus, ZeqImaginarioGraus)\n",
        "print(\"\\nZeq = \" + str(ZeqRect))\n",
        "\n",
        "# ZeqArray - Separando a parte real da imaginária\n",
        "ZeqArray = []\n",
        "ZeqArray = str(ZeqRect).split(\"+\")\n",
        "ZeqArray[0] = ZeqArray[0].replace(\"(\", \"\")\n",
        "ZeqArray[1] = ZeqArray[1].replace(\")\", \"\")\n",
        "print(\"\\nZeqArray = \" + str(ZeqArray))\n",
        "\n",
        "# Z1Array - Separando a parte real da imaginária\n",
        "Z1Array = []\n",
        "Z1Array = str(Z1).split(\"+\")\n",
        "Z1Array[0] = Z1Array[0].replace(\"(\", \"\")\n",
        "Z1Array[1] = Z1Array[1].replace(\")\", \"\")\n",
        "print(\"\\nZ1Array = \" + str(Z1Array))\n",
        "\n",
        "# Realizando a soma final, do resultado da divisão entre Z2 e Xm, e somando com o Z1\n",
        "# Ou seja, Zeq = (Z2 / Xm) + Z1\n",
        "ZeqTotal = [] \n",
        "ZeqTotal.append(float(ZeqArray[0]) + float(Z1Array[0]))\n",
        "ZeqTotal.append(float(str(ZeqArray[1]).replace(\"j\",\"\")) + float(str(Z1Array[1]).replace(\"j\",\"\")) )\n",
        "\n",
        "# Conversão do valor resultante de Zeq em Retangular\n",
        "ZeqTotalComplex = complex(ZeqTotal[0], ZeqTotal[1])\n",
        "print(\"\\nZeqTotal (complexo)= \" + str(ZeqTotalComplex))\n",
        "\n",
        "# Conversão do valor resultante de Zeq em Polar\n",
        "ZeqTotalPolar = cmath.polar(ZeqTotalComplex)\n",
        "ZeqTotalPolarArray = []\n",
        "ZeqTotalPolarArray.append(str(ZeqTotalPolar[0]))\n",
        "ZeqTotalPolarArray.append(str((float(ZeqTotalPolar[1])*RadToDegrees)))\n",
        "\n",
        "print(\"\\nZeqTotal (polar)= \" + str(ZeqTotalPolarArray))\n",
        "\n",
        "# Cálculo final da corrente do Estator\n",
        "print(\"\\nI1 = (V1 / Zeq)\")\n",
        "\n",
        "V1 = (460 / pow(3,0.5))\n",
        "\n",
        "I1 = []\n",
        "I1.append(float(V1) / float(ZeqTotalPolarArray[0]))\n",
        "I1.append(\"-\" + str(ZeqTotalPolarArray[1]))\n",
        "\n",
        "print(\"\\nI1 = \" + str(I1[0]) + \" < \" + str(I1[1]) + \" Ampére\")\n",
        "\n",
        "print(\"\\nI1 (módulo) = \" + str(I1[0]) + \" Ampére\")"
      ],
      "execution_count": 162,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Etapa 2: Resultados\n",
            "\n",
            "Z1 = (0.271+1.12j) Ohms\n",
            "\n",
            "Z2 = (11.75+1.91j) Ohms\n",
            "\n",
            "Xm rect = 23.1j\n",
            "\n",
            "XmPolar = [23.1, 1.5707963267948966]\n",
            "\n",
            "Z2Array * XmPolarArray = 271.425\n",
            "\n",
            "Z2PolarArray = [11.904226140325123, 9.232855460038456]\n",
            "\n",
            "Z2ParalellXm = ['274.98762384151036', ' < ', '99.23285546003845']\n",
            "\n",
            "Z2ParalellXm = ['274.98762384151036', ' < ', '99.23285546003845', '11.75', '+', 25.01]\n",
            "\n",
            "Z2ParalellXmRadianos = (27.632636501065186, 1.1315893738413583)\n",
            "\n",
            "Z2ParalellXmDegrees = [27.632636501065186, 64.83529526296135]\n",
            "\n",
            "Z2ParalellXmResult = [9.95155217385464, 34.3975601970771]\n",
            "\n",
            "ZeqRealGraus = 8.211399432083239\n",
            "\n",
            "ZeqImaginarioGraus = 5.621948953497719\n",
            "\n",
            "Zeq = (8.211399432083239+5.621948953497719j)\n",
            "\n",
            "ZeqArray = ['8.211399432083239', '5.621948953497719j']\n",
            "\n",
            "Z1Array = ['0.271', '1.12j']\n",
            "\n",
            "ZeqTotal (complexo)= (8.48239943208324+6.741948953497719j)\n",
            "\n",
            "ZeqTotal (polar)= ['10.835357669083889', '38.478248118682124']\n",
            "\n",
            "I1 = (V1 / Zeq)\n",
            "\n",
            "I1 = 24.510600566975313 < -38.478248118682124 Ampére\n",
            "\n",
            "I1 (módulo) = 24.510600566975313 Ampére\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yxinZuKV2kou"
      },
      "source": [
        "## Etapa 3: Cálculo de fator de potência (FP)\n",
        "\n",
        "FP = cos 𝜽"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dl-MoOmp2aMz",
        "outputId": "f786ebc4-7322-4cd3-fdc8-97c97f49361b"
      },
      "source": [
        "cosI1FP = cmath.cos(-2.8656)\n",
        "\n",
        "print(\"\\n cosI1FP = \" + str(cosI1FP))"
      ],
      "execution_count": 163,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            " cosI1FP = (-0.9621551714625783+0j)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5zE00DpR0vNd"
      },
      "source": [
        "## Etapa 4: Corrente de rotor\n",
        "\n",
        "### Sub-etapa: Tensão de Thevénin\n",
        "\n",
        "Vth = V𝜽 * (Xm / √((R1^2) + (X1 + Xm)^2))\n",
        "\n",
        "---\n",
        "\n",
        "### Sub-etapa: Resistência de Thevénin\n",
        "\n",
        "Rth = R1 * (Xm / (X1 + Xm))^2\n",
        "\n",
        "---\n",
        "\n",
        "### Sub-etapa: Indutância de Thevénin\n",
        "\n",
        "Xth ≈ X1\n",
        "\n",
        "---\n",
        "\n",
        "### Sub-etapa: Corrente de rotor\n",
        "\n",
        "I2 = (Vth / (Zth + Z2))\n",
        "\n",
        "I2 = (Vth / √(Rth + (R2/s)^2 + (Xth + X2)^2))\n",
        "\n",
        "---\n",
        "\n",
        "#### Gradenzas elétricas:\n",
        "\n",
        "- I1 = Corrente do estator | (A) - Ampère\n",
        "\n",
        "- I2 = Corrente do rotor | (A) - Ampère\n",
        "\n",
        "- R1 = Resistência do estator | (Ω) - Ohms\n",
        "\n",
        "- R2 = Resistência do rotor | (Ω) - Ohms\n",
        "\n",
        "- V𝜽 = Tensão de fase | (V) - Volts\n",
        "\n",
        "- Vth = Tensão de Thevénin no rotor | (V) - Volts\n",
        "\n",
        "- X1 = Indutância do rotor | (Ω) - Ohms\n",
        "\n",
        "- Xth = Indutância de Thevénin | (Ω) - Ohms\n",
        "\n",
        "- Xm = Indutância | (Ω) - Ohms\n",
        "\n",
        "\n",
        "![](https://github.com/HenriqueMAP/electrical-induction-motor/blob/main/Explicacao-conjugado.png?raw=true)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bRLHxy3fE_WY",
        "outputId": "f041c34a-3cfc-409b-e94e-e3de83d1248c"
      },
      "source": [
        "V0 = (460 / pow(3, 0.5))\n",
        "R1 = 0.271\n",
        "X1 = 1.12\n",
        "R2 = 0.188\n",
        "X2 = 1.91\n",
        "Xm = 23.10\n",
        "s  = 0.016\n",
        "\n",
        "Vth = V0 * (Xm / pow((pow(R1, 2) + pow((X1 + Xm), 2)), 0.5))\n",
        "print(\"\\nVth - Tensão de Thevénin = \" + str(Vth) + \" Volts\")\n",
        "\n",
        "Rth = R1 * pow((Xm / (X1 + Xm)),0.5)\n",
        "print(\"\\nRth - Resistência de Thevénin = \" + str(Rth) + \" Ω\")\n",
        "\n",
        "Xth = X1\n",
        "\n",
        "I2 = (Vth / pow((Rth + pow((R2/s),2) + pow((Xth + X2),2)), 0.5))\n",
        "print(\"\\nI2 - Corrente do Rotor = \" + str(I2) + \" A\")\n",
        "\n",
        "Pef = (pow((3*I2), 2) * (R2/s)) / 1000\n",
        "print(\"\\nPEF - Perda no Entreferro = \" + str(Pef) + \" Watts ou kVa?\")"
      ],
      "execution_count": 164,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Vth - Tensão de Thevénin = 253.28406121497767 Volts\n",
            "\n",
            "Rth - Resistência de Thevénin = 0.26465994104333884 Ω\n",
            "\n",
            "I2 - Corrente do Rotor = 20.854509785319273 A\n",
            "\n",
            "PEF - Perda no Entreferro = 45.9917936643171 Watts ou kVa?\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KTYpkErF0xIz"
      },
      "source": [
        "## Etapa 5: Conjugado de partida"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 346
        },
        "id": "fEcXd1CjE_WZ",
        "outputId": "86dad7b3-9b68-4826-9a60-cf713db509a3"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "Wsinc = (n_sinc / 9.5492)\n",
        "\n",
        "Tind = (pow((3*Vth),2) * (R2 / s)) / (Wsinc * (pow((Rth + (R2 / s)),2) + (pow((Xth + X2),2) )))\n",
        "print(\"\\nConjugado induzido = \" + str(Tind) + \" Nm\\n\")\n",
        "\n",
        "fig1, grafico1 = plt.subplots()\n",
        "velocidadeMec1 = 0\n",
        "SlippingUp1 = []\n",
        "\n",
        "\n",
        "for escorregamento in range(-1200,1200):\n",
        "  if escorregamento != 0:\n",
        "    SlippingUp1.append(float(1 / escorregamento))\n",
        "\n",
        "\n",
        "SlippingUp1 = np.array(SlippingUp1)\n",
        "\n",
        "index = 0 \n",
        "Tind1 = []\n",
        "\n",
        "for velocidadeSincrona in range(-1200,1200):\n",
        "  if velocidadeSincrona != 0:\n",
        "    slipping = float(SlippingUp1[index])\n",
        "    Tind1.append(float((pow((3*Vth),2) * (R2 / slipping)) / (Wsinc * (pow((Rth + (R2 / slipping)),2) + (pow((Xth + X2),2) )))))\n",
        "    index += 1\n",
        "\n",
        "\n",
        "Tind1 = np.array(Tind1)\n",
        "\n",
        "index = 0 \n",
        "Tind2 = []\n",
        "\n",
        "for velocidadeSincrona in range(-1200,1200):\n",
        "  if velocidadeSincrona != 0:\n",
        "    slipping = float(SlippingUp1[index])\n",
        "    Tind2.append(float((pow((3*Vth),2) * ((2*R2) / slipping)) / (Wsinc * (pow((Rth + ((2*R2) / slipping)),2) + (pow((Xth + X2),2) )))))\n",
        "    index += 1\n",
        "\n",
        "\n",
        "Tind2 = np.array(Tind2)\n",
        "\n",
        "\n",
        "grafico1.plot(SlippingUp1, Tind1, color='green', marker='o', linestyle='solid')\n",
        "grafico1.plot(SlippingUp1, Tind2, color='blue', marker='o', linestyle='solid')\n",
        "\n",
        "grafico1.set(xlabel='Velocidade síncrona (%)', ylabel='Conjugado induzido (Nm)',\n",
        "       title='Conjugado versus Velocidade')\n",
        "grafico1.grid()\n",
        "\n",
        "fig1.savefig(\"test.png\")\n",
        "plt.show()\n"
      ],
      "execution_count": 165,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Conjugado induzido = 351.6253983605509 Nm\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fuUuEciD0yqC"
      },
      "source": [
        "## Etapa 6: Conjugado máximo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w2H0ymP_nZe7",
        "outputId": "910e8ac0-8316-4698-c6d0-2cd313b22cc5"
      },
      "source": [
        "print(\"\\nConjugado máximo = \" + str(np.amax(Tind1)) + \" Nm\")"
      ],
      "execution_count": 166,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Conjugado máximo = 694.801512867992 Nm\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WOOSY5jX00L8"
      },
      "source": [
        "## Etapa 7: Escorregamento máximo"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RC7oAtHPJUch",
        "outputId": "eb104459-cdfc-4062-f9ee-1fd7163dd26c"
      },
      "source": [
        "arrayLenght = len(SlippingUp1)\n",
        "print(\"Escorregamento máximo = \" + str(SlippingUp1[arrayLenght - 1199]) + \" %\")\n",
        "\n",
        "array2Lenght = len(Tind1)\n",
        "print(\"\\nConjugado no ponto do escorregamento máximo = \" + str(Tind1[array2Lenght - 1199]) + \" Nm\")"
      ],
      "execution_count": 167,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Escorregamento máximo = 1.0 %\n",
            "\n",
            "Conjugado no ponto do escorregamento máximo = 92.0302244766347 Nm\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0bl0_q3w01i7"
      },
      "source": [
        "## Etapa 8: Velocidade de ocorrência do escorregamento"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 346
        },
        "id": "H9Ac3mYgNIb6",
        "outputId": "07f852d5-6eb2-427c-8d31-ea3fd365ea97"
      },
      "source": [
        "velocidadeMec = []\n",
        "\n",
        "for escorregamentoVariavel in range(-1200,1200):\n",
        "  if escorregamentoVariavel != 0:\n",
        "    velocidadeMec.append(float((1 - escorregamentoVariavel) * n_sinc))\n",
        "\n",
        "velocidadeMec = np.array(velocidadeMec)\n",
        "print(\"\\nVelocidade mecânica (rpm) = \" + str(velocidadeMec) + \"\\n\")\n",
        "\n",
        "fig3, grafico3 = plt.subplots()\n",
        "grafico3.plot(velocidadeMec, Tind1, color='green', marker='o', linestyle='solid')\n",
        "grafico3.plot(velocidadeMec, Tind2, color='blue', marker='o', linestyle='solid')\n",
        "\n",
        "grafico3.set(xlabel='Velocidade mecânica (%)', ylabel='Conjugado induzido (Nm)',\n",
        "       title='Conjugado versus Velocidade de ocorrência do escorregamento')\n",
        "grafico3.grid()\n",
        "\n",
        "fig3.savefig(\"test.png\")\n",
        "plt.show()"
      ],
      "execution_count": 168,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Velocidade mecânica (rpm) = [ 1441200.  1440000.  1438800. ... -1435200. -1436400. -1437600.]\n",
            "\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}