Aqui está a procedure em WLanguage que detecta a quantidade total de memória, paginação, memória usada e memória livre do sistema, retornando essas informações em um array:

```wlanguage
//##############################
// Procedure para verificar informações da memória
PROCEDURE CheckMemoryInfo()

// Declaração de variáveis
memoryInfoArray is array of string
totalMemory is real
usedMemory is real
freeMemory is real
pagingFileTotal is real
pagingFileUsed is real
pagingFileFree is real

// Obtendo a memória total e livre
totalMemory = SysSpace(SysMemory, ssTotal)
freeMemory = SysSpace(SysMemory, ssFree)
usedMemory = totalMemory - freeMemory

// Obtendo informações sobre o arquivo de paginação (pagefile)
pagingFileTotal = SysSpace(SysPagingFile, ssTotal)
pagingFileFree = SysSpace(SysPagingFile, ssFree)
pagingFileUsed = pagingFileTotal - pagingFileFree

// Preenchendo o array com as informações de memória
memoryInfoArray[1] = "Total Memory: " + NumToString(totalMemory, "*.* GBytes")
memoryInfoArray[2] = "Used Memory: " + NumToString(usedMemory, "*.* GBytes")
memoryInfoArray[3] = "Free Memory: " + NumToString(freeMemory, "*.* GBytes")
memoryInfoArray[4] = "Total Paging File: " + NumToString(pagingFileTotal, "*.* GBytes")
memoryInfoArray[5] = "Used Paging File: " + NumToString(pagingFileUsed, "*.* GBytes")
memoryInfoArray[6] = "Free Paging File: " + NumToString(pagingFileFree, "*.* GBytes")

// Retornando o array com as informações
RESULT memoryInfoArray
//##############################
```

### Explicação do código:
1. **`SysSpace(SysMemory, ssTotal)`**: Retorna a quantidade total de memória física disponível no sistema.
2. **`SysSpace(SysMemory, ssFree)`**: Retorna a quantidade de memória livre disponível no sistema.
3. **Cálculo da memória usada**: Subtraímos a memória livre da memória total para obter a memória usada.
4. **`SysSpace(SysPagingFile, ssTotal)`**: Retorna o tamanho total do arquivo de paginação (memória virtual).
5. **`SysSpace(SysPagingFile, ssFree)`**: Retorna o espaço livre disponível no arquivo de paginação.
6. **Array**: Armazena a memória total, memória usada, memória livre, tamanho total do arquivo de paginação, tamanho usado e tamanho livre do arquivo de paginação.

### Como usar:
Você pode chamar essa procedure e obter as informações da memória do sistema assim:

```wlanguage
myMemoryInfo is array of string = CheckMemoryInfo()
FOR EACH info OF myMemoryInfo
Trace(info)
END
```

Esse código exibirá as informações de memória no **Trace**, incluindo a quantidade total de memória, memória usada, memória livre e as informações sobre o arquivo de paginação.

Se precisar de ajustes ou tiver outra questão, é só me avisar!

Para computadores com multi CPUs

Caso o sistema tenha mais de um processador (como 4 processadores, por exemplo), você precisará modificar a procedure para coletar o uso e a temperatura de cada um separadamente e retornar as informações de todos os processadores. O **WMIC** já suporta múltiplos processadores e retornará os dados de todos eles. Precisamos então iterar sobre os resultados e armazenar cada uso e temperatura em arrays separados.

Aqui está a procedure atualizada para lidar com múltiplos processadores:

```wlanguage
//##############################
// Procedure para verificar uso e temperatura de múltiplos processadores
PROCEDURE CheckMultiCPUInfo()

// Declaração de variáveis
cpuInfoArray is array of string
cpuUsageArray is array of real
cpuTempArray is array of real
cpuCount is int

// Comando para obter o uso da CPU (percentual)
USE_CPU is string = "wmic cpu get loadpercentage"
ResUso is string = fExecuteExternal(USE_CPU, fWaitResult)
IF ResUso ~= "" THEN
// Extrair as linhas de resultado, removendo as linhas vazias
arrUsage is array of string = StringToArray(ResUso, CR) // Quebrar as linhas de resultado
cpuCount = ArrayCount(arrUsage) - 1 // Subtrai 1 para excluir o cabeçalho
FOR i = 2 TO cpuCount + 1 // Começa da segunda linha, pois a primeira é o cabeçalho
cpuUsageArray[i-1] = Val(arrUsage[i])
END
ELSE
RETURN "Erro: Não foi possível obter o uso da CPU"
END

// Comando para obter a temperatura da CPU
USE_TEMP is string = "wmic /namespace:\\root\wmi PATH MSAcpi_ThermalZoneTemperature get CurrentTemperature"
ResTemp is string = fExecuteExternal(USE_TEMP, fWaitResult)
IF ResTemp ~= "" THEN
// O valor de temperatura retornado pelo WMI está em unidades de 1/10 Kelvin
arrTemp is array of string = StringToArray(ResTemp, CR) // Quebrar as linhas de resultado
FOR i = 2 TO ArrayCount(arrTemp)
cpuTempArray[i-1] = (Val(arrTemp[i]) / 10) - 273.15 // Convertendo de Kelvin para Celsius
END
ELSE
RETURN "Erro: Não foi possível obter a temperatura da CPU"
END

// Preenchendo o array com as informações de todos os processadores
FOR i = 1 TO cpuCount
cpuInfoArray[i] = "CPU " + NumToString(i) + ": Usage = " + NumToString(cpuUsageArray[i], "*.*") + "%, Temperature = " + NumToString(cpuTempArray[i], "*.*") + " °C"
END

// Retornando o array com as informações
RESULT cpuInfoArray
//##############################
```

### Explicação do código atualizado:
1. **Uso da CPU para múltiplos processadores**: O comando `wmic cpu get loadpercentage` retorna o uso para todos os processadores. Nós utilizamos a função `StringToArray()` para dividir o resultado em linhas e então iterar sobre cada linha para extrair os valores de uso de CPU para cada processador.
2. **Temperatura da CPU para múltiplos processadores**: O comando `wmic /namespace:\\root\wmi PATH MSAcpi_ThermalZoneTemperature get CurrentTemperature` retorna a temperatura para todas as zonas térmicas (cada processador). Nós convertemos os valores de Kelvin para Celsius e os armazenamos no array `cpuTempArray`.
3. **Loop para adicionar as informações ao array**: O array `cpuInfoArray` é preenchido com as informações de uso e temperatura de cada processador, formatando uma string para cada CPU.

### Como usar:
Você pode chamar essa procedure e exibir as informações de todos os processadores assim:

```wlanguage
myMultiCPUInfo is array of string = CheckMultiCPUInfo()
FOR EACH info OF myMultiCPUInfo
Trace(info)
END
```

Isso exibirá o uso e a temperatura de cada CPU no **Trace**, organizando as informações em uma lista.

### Nota:
- **WMIC** retorna informações de todos os processadores, e este código garante que os dados sejam processados corretamente.
- Caso a saída do **WMIC** não inclua todas as temperaturas ou se houver problemas de leitura em máquinas específicas, pode ser necessário ajustar a forma de obtenção da temperatura para sistemas mais recentes ou específicos.

Se precisar de mais ajustes, só avisar!

Vamos melhorar o exemplo anterior utilizando passagem de parâmetros na procedure, além de recursos mais modernos disponíveis na versão 29 do WinDev. Isso permitirá que a procedure seja mais flexível e reutilizável.

### Procedure com passagem de parâmetros e recursos da versão 29:

Na versão 29, temos melhorias na segurança e na codificação de mensagens. Vamos passar os seguintes parâmetros para a procedure:
- **SMTP server**: endereço do servidor SMTP.
- **Port**: porta usada para o envio (587 para TLS).
- **Sender email**: o e-mail do remetente.
- **Password**: senha do e-mail do remetente.
- **Recipient email**: e-mail do destinatário.
- **Subject**: assunto do e-mail.
- **Message**: corpo da mensagem.

Aqui está a procedure atualizada:

```wlanguage
//##############################
// Procedure para enviar e-mail com passagem de parâmetros e recursos da versão 29
PROCEDURE SendEmailWithParams(smtpServer is string, smtpPort is int, senderEmail is string, password is string, recipientEmail is string, subject is string, messageText is string)

// Declaração de variáveis para a configuração do SMTP
smtpSession is EmailSMTPSession
smtpSession.ServerAddress = smtpServer // Endereço do servidor SMTP
smtpSession.Name = senderEmail // E-mail do remetente
smtpSession.Password = password // Senha do e-mail
smtpSession.Port = smtpPort // Porta SMTP (padrão 587 para TLS)
smtpSession.Option = emailOptionSecuredTLS // Usar TLS para criptografia (mais seguro)

// Iniciar a sessão SMTP
IF NOT EmailStartSMTPSession(smtpSession) THEN
Error("Erro ao iniciar a sessão SMTP: ", ErrorInfo(errMessage))
RETURN
END

// Configurando a mensagem de e-mail
emailMessage is Email
emailMessage.Sender = senderEmail // Endereço de quem envia
emailMessage.Recipient[1] = recipientEmail // Endereço do destinatário
emailMessage.Subject = subject // Assunto do e-mail
emailMessage.Message = messageText // Corpo da mensagem

// Exemplo de anexo usando recurso da versão 29
// Anexar arquivos usando um array, disponível na versão 29 para maior flexibilidade
attachments is array of string
attachments = ["C:\caminho\para\arquivo.pdf", "C:\caminho\para\outro_arquivo.txt"]

FOR EACH file OF attachments
emailMessage.Attach(file)
END

// Enviar o e-mail
IF NOT EmailSendMessage(smtpSession, emailMessage) THEN
Error("Erro ao enviar o e-mail: ", ErrorInfo(errMessage))
RETURN
END

// Fechar a sessão SMTP
EmailCloseSession(smtpSession)

Info("E-mail enviado com sucesso!")
//##############################
```

### Explicação do código atualizado:

1. **Passagem de parâmetros**:
- **`smtpServer`**: O endereço do servidor SMTP é passado como parâmetro (exemplo: "smtp.gmail.com").
- **`smtpPort`**: A porta usada para a conexão SMTP (geralmente 587 para TLS).
- **`senderEmail`** e **`password`**: O e-mail do remetente e a senha também são passados como parâmetros, permitindo flexibilidade.
- **`recipientEmail`**: O e-mail do destinatário é passado como parâmetro.
- **`subject`** e **`messageText`**: O assunto e o corpo do e-mail são personalizados através da passagem de parâmetros.

2. **Recursos da versão 29**:
- **Array para anexos**: Um recurso interessante na versão 29 é a possibilidade de usar um **array** para anexos, tornando o código mais flexível e organizado.
- **Melhorias de segurança**: O uso de **TLS** para criptografia é mantido com a opção `emailOptionSecuredTLS`, garantindo segurança durante o envio.

3. **Validação de erros aprimorada**:
- **`ErrorInfo(errMessage)`**: Utilizamos essa função para obter informações detalhadas sobre erros, proporcionando uma melhor experiência de depuração.

### Como usar:

Você pode chamar a procedure **`SendEmailWithParams`** passando os parâmetros necessários:

```wlanguage
SendEmailWithParams("smtp.gmail.com", 587, "seuemail@exemplo.com", "sua_senha", "destinatario@exemplo.com", "Assunto do E-mail", "Aqui está o corpo da mensagem.")
```

### Notas adicionais:
- **Segurança**: No caso de servidores de e-mail como Gmail, certifique-se de ativar o suporte para "apps menos seguros" ou configurar um token de autenticação específico, dependendo do provedor de e-mail.
- **Anexos**: No exemplo, mostramos como anexar múltiplos arquivos usando um array. Se quiser enviar sem anexos, basta não definir o array `attachments`.

Essa abordagem torna o envio de e-mail flexível e seguro, utilizando os recursos modernos da versão 29 do WinDev.

Se precisar de mais alguma modificação ou ajuste, estou à disposição!