Run project through 1.6 formatter

The formatter doesn’t respect whitespace in keyword lists or maps, and
that makes the hardware byte lookup tables hard to read. Those parts of
the formatter output were reverted, and I’m hoping that Dave’s GitHub
issue elixir-lang/elixir#6647 gets future
consideration.

lib/rfm69.ex

@@ -1,13 +1,10 @@
 defmodule RFM69 do
   use Bitwise
 
-  require Logger
-
   @device RFM69.Device
   @moduledoc false
   @fifo_size 66
-  # @fifo_threshold 20
-  @transfer_sleep trunc(@fifo_size / 4) # time to wait for fifo to be processed during transfer
+  @transfer_sleep trunc(@fifo_size / 4)
 
   def set_base_frequency(mhz) do
     @device.write_frequency(trunc(mhz * 1_000_000))
@@ -17,19 +14,19 @@ defmodule RFM69 do
     set_auto_modes([])
     set_mode(:receiver)
     @device.await_interrupt()
-    result = receive do
-      {:ok, :interrupt_received} ->
-        Logger.info "Received response"
-        rssi = read_rssi()
-        bytes = read_until_null(<<>>)
-        Logger.debug fn() -> "response: #{Base.encode16(bytes)}" end
-        {:ok, %{data: bytes, rssi: rssi}}
-    after
-      timeout_ms ->
-        Logger.info "Timeout reached"
-        @device.cancel_interrupt()
-        {:error, :timeout}
-    end
+
+    result =
+      receive do
+        {:ok, :interrupt_received} ->
+          rssi = read_rssi()
+          bytes = read_until_null(<<>>)
+          {:ok, %{data: bytes, rssi: rssi}}
+      after
+        timeout_ms ->
+          @device.cancel_interrupt()
+          {:error, :timeout}
+      end
+
     set_mode(:sleep)
     result
   end
@@ -45,6 +42,7 @@ defmodule RFM69 do
         _write(packet_bytes, timeout_ms)
         :timer.sleep(repetition_delay)
         write(packet_bytes, repetitions - 1, repetition_delay, timeout_ms, false)
+
       0 ->
         set_mode(:sleep)
         {:ok, ""}
@@ -74,16 +72,13 @@ defmodule RFM69 do
   end
 
   defp transmit(bytes, available_buffer_bytes) when byte_size(bytes) <= available_buffer_bytes do
-    Logger.debug fn() -> "Transmitting remaining: #{Base.encode16(bytes)}, available_buffer_bytes: #{available_buffer_bytes}" end
     _transmit(bytes)
     wait_for_mode(:standby)
   end
 
   defp transmit(bytes, available_buffer_bytes) do
     <<transmit_now::binary-size(available_buffer_bytes), transmit_later::binary>> = bytes
-    Logger.debug fn() -> "Transmitting initial: #{Base.encode16(transmit_now)}, available_buffer_bytes: #{available_buffer_bytes}" end
     available_buffer_bytes = _transmit(transmit_now)
-    Logger.debug fn() -> "Queueing rest: #{Base.encode16(transmit_later)}, new available_buffer_bytes: #{available_buffer_bytes}" end
     transmit(transmit_later, available_buffer_bytes)
   end
 
@@ -95,8 +90,7 @@ defmodule RFM69 do
 
   @reg_irq_flags2 0x28
   @fifo_overrun 0x10
-  defp clear_fifo() do
-    # Logger.debug "Clearing FIFO"
+  defp clear_fifo do
     @device.write_single(@reg_irq_flags2, @fifo_overrun)
   end
 
@@ -105,40 +99,39 @@ defmodule RFM69 do
     (@device.read_single(@reg_irq_flags2) &&& @fifo_level) != 0x00
   end
 
-  defp wait_for_buffer_to_become_available() do
-    # Logger.debug "Waiting for buffer to become available"
+  defp wait_for_buffer_to_become_available do
     case fifo_threshold_exceeded?() do
       true -> wait_for_buffer_to_become_available()
-      false -> nil # Logger.debug "Buffer available"
+      false -> nil
     end
   end
 
-  @reg_op_mode      0x01
+  @reg_op_mode 0x01
   @modes %{
-    sequencer_off:    0x80,
-    listen_on:        0x40,
-    listen_abort:     0x20,
-    mode_shift:       0x02,
-    mode_mask:        0x1C,
-    sleep:            0x00,
-    standby:          0x04,
-    freq_synth:       0x08,
-    transmitter:      0x0C,
-    receiver:         0x10
+    sequencer_off: 0x80,
+    listen_on:     0x40,
+    listen_abort:  0x20,
+    mode_shift:    0x02,
+    mode_mask:     0x1C,
+    sleep:         0x00,
+    standby:       0x04,
+    freq_synth:    0x08,
+    transmitter:   0x0C,
+    receiver:      0x10
   }
   def set_mode(mode) do
     mode = Map.get(@modes, mode)
     current_mode = get_mode()
+
     case mode do
       ^current_mode -> true
       _ ->
-        # Logger.debug fn() -> "Setting mode to #{inspect(mode)}" end
         @device.write_single(@reg_op_mode, mode)
         wait_for_mode_ready(mode)
     end
   end
 
-  defp get_mode() do
+  defp get_mode do
     @device.read_single(@reg_op_mode)
   end
 
@@ -161,9 +154,11 @@ defmodule RFM69 do
     intermediate_mode_tx:           0x03
   }
   defp set_auto_modes(modes) do
-    register_value = modes
-    |> Enum.map(fn(mode) -> @auto_modes[mode] end)
-    |> Enum.reduce(0x00, &(&1 ||| &2))
+    register_value =
+      modes
+      |> Enum.map(fn mode -> @auto_modes[mode] end)
+      |> Enum.reduce(0x00, &(&1 ||| &2))
+
     @device.write_single(@reg_auto_modes, register_value)
   end
 
@@ -185,10 +180,4 @@ defmodule RFM69 do
     {:ok, <<raw_rssi::8>>} = @device.read_burst(@reg_rssi_val, 1)
     -1 * trunc(raw_rssi) / 2
   end
-
-  # def read_hardware_version() do
-  #   <<_::8, version::4, metal_mask::4>> = SPI.transfer(<<0x1000::16>>)
-  #   IO.puts "Version: #{version}, Metal Version: #{metal_mask}"
-  #   version
-  # end
 end

lib/rfm69/configuration.ex

@@ -277,7 +277,7 @@ defmodule RFM69.Configuration do
 
   @oscillator_frequency 32_000_000
   def frequency_to_registers(frequency_in_hz) do
-    trunc(((frequency_in_hz <<< 19) + (@oscillator_frequency / 2)) / @oscillator_frequency)
+    trunc(((frequency_in_hz <<< 19) + @oscillator_frequency / 2) / @oscillator_frequency)
   end
 
   def bitrate_to_registers(bitrate) do

lib/rfm69/device.ex

@@ -18,12 +18,11 @@ defmodule RFM69.Device do
          {:ok, reset_pid} <- GPIO.start_link(reset_pin, :output),
          {:ok, interrupt_pid} <- GPIO.start_link(interrupt_pin, :input),
          :ok <- GPIO.write(reset_pid, 0) do
-
       {:ok, %{spi_pid: spi_pid, reset_pid: reset_pid, interrupt_pid: interrupt_pid}}
     else
       error ->
         message = "The SPI RFM69 chip interface failed to start"
-        Logger.error fn() -> "#{message}: #{inspect(error)}" end
+        Logger.error(fn -> "#{message}: #{inspect(error)}" end)
         {:error, message}
     end
   end
@@ -33,7 +32,9 @@ defmodule RFM69.Device do
     value
   end
 
-  def read_burst(location, byte_count), do: GenServer.call(__MODULE__, {:read_burst, location, byte_count})
+  def read_burst(location, byte_count),
+    do: GenServer.call(__MODULE__, {:read_burst, location, byte_count})
+
   def write_burst(location, data), do: GenServer.call(__MODULE__, {:write_burst, location, data})
   def write_single(location, data), do: write_burst(location, <<data::8>>)
   def reset, do: GenServer.call(__MODULE__, {:reset})
@@ -71,7 +72,7 @@ defmodule RFM69.Device do
 
   @write_mode 0x80
   def handle_call({:write_burst, location, data}, _from, state = %{spi_pid: spi_pid}) do
-    tx_bytes = <<(@write_mode ||| location)::8>> <> data
+    tx_bytes = <<@write_mode ||| location::8>> <> data
     SPI.transfer(spi_pid, tx_bytes)
     {:reply, :ok, state}
   end
@@ -93,7 +94,10 @@ defmodule RFM69.Device do
     {:reply, :ok, Map.delete(state, :awaiting_interrupt)}
   end
 
-  def handle_info({:gpio_interrupt, _, :rising}, state = %{awaiting_interrupt: awaiting_interrupt, interrupt_pid: interrupt_pid}) do
+  def handle_info(
+        {:gpio_interrupt, _, :rising},
+        state = %{awaiting_interrupt: awaiting_interrupt, interrupt_pid: interrupt_pid}
+      ) do
     GPIO.set_int(interrupt_pid, :none)
     send(awaiting_interrupt, {:ok, :interrupt_received})
     {:noreply, Map.delete(state, :awaiting_interrupt)}
@@ -102,8 +106,4 @@ defmodule RFM69.Device do
   def handle_info({:gpio_interrupt, _, _}, state) do
     {:noreply, state}
   end
-
-  # defp genserver_timeout(timeout_ms) do
-  #   timeout_ms + 2_000
-  # end
 end

test/rfm69/rf_configuration_test.exs → test/rfm69/configuration_test.exs

@@ -14,8 +14,10 @@ defmodule RFM69.RFConfigurationTest do
       data_modul: 0x08,
       pa_level: 0x5F,
       lna: 0x88,
-      rx_bw: 0x40, # 250kHz with dcc freq shift 2, RxBwMant of 16 and RxBwExp of 0
-      afc_bw: 0x80, # dcc freq shift of 4
+      # 250kHz with dcc freq shift 2, RxBwMant of 16 and RxBwExp of 0
+      rx_bw: 0x40,
+      # dcc freq shift of 4
+      afc_bw: 0x80,
       dio_mapping1: 0x80,
       dio_mapping2: 0x07,
       rssi_thresh: 0xE4,
@@ -28,7 +30,11 @@ defmodule RFM69.RFConfigurationTest do
       packet_config2: 0x00
     }
 
-    {:ok, expected_bytes} = Base.decode16("00040807A10052E5266641000292F520245F091A40B07B9B884080408006100000000002FF80078000E40000001898FF00FF000101010100000000009400000000000000000000000000000000000100")
+    {:ok, expected_bytes} =
+      Base.decode16(
+        "00040807A10052E5266641000292F520245F091A40B07B9B884080408006100000000002FF80078000E40000001898FF00FF000101010100000000009400000000000000000000000000000000000100"
+      )
+
     assert expected_bytes == RFConfiguration.to_binary(test_configuration)
   end
 end