class A_Pin(D_Pin): def __init__(self, pin): #self.pin = pin self.dac = None self.adc = None if pin in [25, 26]: self.dac = DAC(Pin(pin)) if pin in [32, 33]: self.adc = ADC(Pin(pin)) self.adc.atten(ADC.ATTN_11DB) self.adc.width(ADC.WIDTH_10BIT) super().__init__(pin) def write_analog(self, value): if self.pin not in [25, 26]: # print("This pin feature is not supported") super().write_analog(value) else: self.dac.write(value) def read_analog(self): if self.adc != None: return self.adc.read() else: print('This Pin does not support ADC') return None
def create_data_file(starting_value, button_pin, sensor_pin, led_pin, blue, red, green, counter): button = machine.Pin(button_pin, machine.Pin.IN) #define button pin adc33 = ADC(machine.Pin(sensor_pin)) #define sensor pin adc33.atten(ADC.ATTN_6DB) #define adc dac26 = DAC(machine.Pin(led_pin)) #define DAC dac26.write(starting_value) #adjust the intensity of the LED data = [] i = 0 f = open('data' + str(counter), 'w') while True: time.sleep(1) #Take the average of the measurments every 1,2 seconds sum = 0 for i in range(12000): if button.value() == 1: break sum = sum + adc33.read() time.sleep(0.01) average = sum / 12000 data.append(average) f.write("%s\n" % average) print("\n") print(average) if button.value() == 1: #button is pressed again color("blue", blue, red, green) time.sleep(1) break i = i + 1 f.close()
class Speak: def __init__(self): # init dac self.dac = DAC(Pin(25)) # init params self.__volume = 8 def set_volume(self, volume): if (volume <= 10) and (volume >= 0): self.__volume = 11 - volume else: print('the volume must be in 0 to 10') def play_music(self, filename, rate): delay_interval = int(1000000 / rate) last_data = 0 f = open(filename, 'r') if self.__volume != 11: while True: data = f.read(4) if data == '': for i in range(int(last_data / self.__volume), 0, -1): self.dac.write(i) time.sleep_ms(2) f.close() return else: data = int(data.strip()) self.dac.write(int(data / self.__volume)) time.sleep_us(delay_interval) last_data = data
class BatteryService(object): def __init__(self): self.powerPin = 0 self.adc = 0 self.Battery = 0 self.vBiasDAC = 0 def confService(self): self.powerPin = Pin('P8', mode=Pin.OUT) self.adc = ADC() self.adc.vref(1058) self.vBiasDAC = DAC('P22') self.vBiasDAC.write(0.135) # approximately 0.5 V self.Battery = self.adc.channel(pin='P14', attn = ADC.ATTN_11DB) def getData(self): self.powerPin(1) time.sleep(0.002) batt = self.Battery.voltage() collectMemory() self.powerPin(0) return batt def connect(self): self.confService()
class ODSensor: # frequency and pins may need to be changed def __init__(self,LEDPin, sensorPin): #25,39. 26,36. self.DAC_MAX = 255 self.DAC_Vmax = 3.15 self.DAC_Vmin = 0.09 self.led = DAC(Pin(25), bits=8) self.sensor = ADC(Pin(39)) #Green #self.sensor.atten(ADC.ATTN_11DB) self.sensor.width(ADC.WIDTH_10BIT) # return a single measurement def measure(self, intensity): self.led.write(intensity) data = [] #get 120 measurements for j in range(120): data.append(self.sensor.read()) data.sort() #sort data increasing sum_middle = sum(data[30:90]) #find sum of middle numbers avg = sum_middle / 60 #find average of middle numbers return avg
def experiment(starting_value, button_pin, sensor_pin, led_pin, blue, red, green): button = machine.Pin(button_pin, machine.Pin.IN) #define button pin adc33 = ADC(machine.Pin(sensor_pin)) #define sensor pin adc33.atten(ADC.ATTN_6DB) #define adc dac26 = DAC(machine.Pin(led_pin)) #define DAC dac26.write(starting_value) #adjust the intensity of the LED data = [] i = 0 counter = 0 while not count_time(button_pin): print("here!!") if button.value() == 1: color("green", blue, red, green) #if the experiment runs neopixel gives green color if counter < 5: create_data_file(starting_value, button_pin, sensor_pin, led_pin, blue, red, green, counter) #create new data file counter += 1 color("purple", blue, red, green) color("white", blue, red, green) time.sleep(5) color("no", blue, red, green) #Take the of the measurments every 1,2 seconds sum = 0 for i in range(120): if button.value() == 1: break sum = sum + adc33.read() time.sleep(0.01) average = sum / 12000
def signal_generator(pin=25, buffer_size=100, freq=.1): # create a buffer containing a sine-wave buf = bytearray(buffer_size) for i in range(len(buf)): buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf))) # output the sine-wave at 400Hz p = Pin(pin, Pin.OUT) dac = DAC(p) while True: for i in buf: dac.write(i) time.sleep(freq)
def play(filename, pin): try: p = Pin(pin, Pin.OUT) dac = DAC(p) except Exception as e: return str(e) f = wave.open(filename, 'r') total_frames = f.getnframes() framerate = f.getframerate() for position in range(0, total_frames, framerate): f.setpos(position) # dac.write_timed(f.readframes(framerate), framerate) dac.write(f.readframes(framerate)) sleep_ms(1000)
def test(): buf = bytearray(100) dac = DAC(Pin(25, Pin.OUT)) for i in range(len(buf)): buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf))) #print(1 "{",buf[i],"}") #dac.write(buf[i]) test_count=0 flag= False while flag==False: for i in range(len(buf)): print(1, "{",buf[i],"}") dac.write(buf[i]) time.sleep(0.1) test_count=test_count+1 if test_count==9000: flag=True print("end 1")
def experiment(starting_value, button_pin, sensor_pin, led_pin): button = machine.Pin(button_pin, machine.Pin.IN) #define button pin adc33 = ADC(machine.Pin(sensor_pin)) #define sensor pin adc33.atten(ADC.ATTN_11DB) #define adc dac26 = DAC(machine.Pin(led_pin)) #define DAC dac26.write(starting_value) #adjust the intensity of the LED data = [] i = 0 while True: if button.value() == 1: f = open('data', 'w') while True: time.sleep(0.1) data.append(adc33.read()) f.write("%s\n" % adc33.read()) # print(data[i - 1]) if button.value() == 1: time.sleep(1) break i = i + 1 f.close()
class Stepper: def __init__(self): self.coils = [pins.motor_1, pins.motor_2, pins.motor_3, pins.motor_4] self.vref_12 = DAC(pins.motor_vref_a) self.vref_34 = DAC(pins.motor_vref_b) self.sequence = [[1, 0, 0, 0], [1, 1, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 1, 1], [0, 0, 0, 1]] def activate(self, index): values = self.sequence[index] for i in range(4): self.coils[i].on() if values[i] else self.coils[i].off() def step(self): self.vref_12.write(30) self.vref_34.write(30) for i in range(len(self.sequence)): self.activate(i) sleep_us(10000) self.vref_12.write(0) self.vref_34.write(0)
''' Send the value 0..256 to the DAC and read the analogue value back on the ADC Copyright (c) U. Raich 2020 This program is part of the course on IoT at the University of Cape Coast, Ghana ''' from machine import Pin, ADC, DAC from time import sleep_ms adc = ADC(Pin(36)) # create ADC object on ADC pin adc.atten(ADC.ATTN_11DB) dac = DAC(Pin(26)) file = open("linearity.dat", "w") print( "Send values from 0 ..255 to DAC and read the signal level back on the ADC" ) print("The ADC values are saved in the file 'linearity.dat'") for i in range(256): # send the value to the DAC and wait for 50 ms to stabilize # then read back the signal level on the DAC dac.write(i) sleep_ms(50) file.write("{:d}\n".format(adc.read())) for i in range(255): dac.write(254 - i) sleep_ms(50) file.write("{:d}\n".format(adc.read())) file.close()
#simple DAC from machine import DAC from machine import Pin dac0 = DAC(Pin(25)) dac1 = DAC(Pin(26)) dac0.write(128) #1.75V dac1.write(64) #0.9V
#Hardware Platform: FireBeetle-ESP32 #Result: IO25 output sin wave, IO26 output cos wave. #Hardware Connection: IO25 and IO26 need to be connected to an oscilloscope if waveform observation is needed. #The info below shows that waveform is available for the current version. # IO25 IO26 #FireBeetle-ESP32 has 2 DAC signal pins in all. from machine import DAC, Pin import math import time dac0 = DAC(Pin(25)) dac1 = DAC(Pin(26)) a = 0 while True: value = math.sin(a * math.pi / 180) #get sine dac0.write(int(100 + value * 100)) #ouput wave dac1.write(a * 255 // 360) a += 1 if (a == 361): a = 0 time.sleep(0.0001)
from machine import Pin, DAC import utime # variabelen DAC_GPIO = 25 buf = [] # initialiseren DAC dac = DAC(Pin(DAC_GPIO)) # zaagtandbuffer opvullen for i in range(0, 100): buf.append(i * 2) # zaagtand naar DAC j = 0 while True: # waarde naar DAC val = buf[j] print(val) dac.write(val) # volgende waarde j += 1 if j >= 100: j = 0 # 20 ms wachten - 100 * 20ms = 2 s utime.sleep_ms(20)
from machine import Pin, Map, DAC # include Pin, Map and DAC from machine module import time # import time module BUZZER = DAC(Pin(Map.WIO_BUZZER)) # create DAC on WIO BUZZER Pin BUZZER.write(180) # write value to DAC, 180/4096*3.3 = 0.145V
global wr global playlist_pos if playlist_pos >= len(wav_files): playlist_pos = 0 wr = loadWav(wav_files[playlist_pos]) t1.init(freq=wav_sample_rate, mode=Timer.PERIODIC, callback=play_loop_all) playlist_pos += 1 sleep(1) # Init DAC dac = DAC(Pin(26)) # Middle value for speaker dac.write(0x7F) dw = dac.write wav_pos = 0 wav_pos_prev = 0 wav_files = list() wav_files.append("assets/wav/s1.wav") wav_files.append("assets/wav/s2.wav") wav_files.append("assets/wav/s3.wav") wav_files.append("assets/wav/oeproj.wav") wav_files.append("assets/wav/s5.wav") wav_files.append("assets/wav/s6.wav") wav_files.append("assets/wav/s7.wav") wav_files.append("assets/wav/upycool.wav")
# Demo 7.5 - Playing tones on the speaker from machine import DAC, Pin from math import sin, pi from time import sleep_us dac = DAC(Pin(25,Pin.OUT)) # create a buffer containing a sine-wave buf = bytearray(50) for i in range(len(buf)): buf[i] = 128 + int(127 * sin(2 * pi * i / len(buf))) while True: for i in range(len(buf)): dac.write(buf[i]) sleep_us(1) # Demo 7.6 - Playing tones on the speaker now with a function from machine import DAC, Pin from math import sin, pi from time import sleep_us dac = DAC(Pin(25,Pin.OUT)) # create a buffer containing a sine-wave buf = bytearray(50) for i in range(len(buf)): buf[i] = 128 + int(127 * sin(2 * pi * i / len(buf))) def playtone(delay, repetition, dac, buf): for j in range(repetition):
from machine import Pin, DAC from time import sleep_ms dac = DAC(Pin(26)) print("Running a triangular wave form with a frequency of ~ 1 Hz on pin 26") while True: for i in range(256): dac.write(i) sleep_ms(2) for i in range(256): dac.write(256 - i - 1) sleep_ms(2)
look_up_ADC = [] # Initialize ADC adc = ADC(Pin(ADC_PIN_NO)) adc.atten(ADC.ATTN_11DB) adc.width(ADC.WIDTH_10BIT) # was 10 # Initialize DAC dac = DAC(Pin(DAC_PIN_NO), bits=8) # Measure adc_read = [] for i in range(0, DAC_MAX+1): print('Samples acquired: ' + str(i) + '/' + str(DAC_MAX)) dac.write(i) utime.sleep_ms(ADC_DELAY) raw_read = [] for i in range(1, NUM_SAMPLES+1): raw_read.append(adc.read()) utime.sleep_ms(DAC_DELAY) adc_read.append(round(sum(raw_read)/NUM_SAMPLES)) # Print result #print(adc_read) adc_V_lookup = [] for i in range(0, ADC_MAX+1): gc.collect() gc.mem_free()
# f = 329Hz # fs = 32.9kHz import math from machine import DAC from machine import Pin dac1 = DAC(Pin(25)) dac2 = DAC(Pin(26)) # create a buffer containing a sine-wave buf = bytearray(100) for i in range(len(buf)): buf[i] = 128 + int(127 * math.sin(2 * math.pi * i / len(buf))) while 1: for i in range(len(buf)): dac2.write(buf[i])
from machine import DAC, Pin import utime da = DAC(Pin(26)) da.write(0)
for i in range(500, 1000, 10): time.sleep(0.01) pwm13.duty(i) data.append(adc33.read()) f.write((data)) ###########################DAC fade in fade out import time import machine from machine import DAC, ADC adc33 = ADC(machine.Pin(33)) adc33.atten(ADC.ATTN_11DB) #define adc dac26 = DAC(machine.Pin(26)) dac26.write(0) time.sleep(1) data = [] f = open('data', 'w') for i in range(1, 255): time.sleep(0.1) dac26.write(i) data.append(adc33.read()) f.write("%s\n" % adc33.read()) print(data[i - 1]) f.close() f = open('data', 'r') #open the file for reading purpose f.read() # then you can read
from cat import Cat from machine import Timer, I2C, Pin, ADC, DAC, TouchPad import limb from time import sleep import network from mpu6050 import MPU6050 from hcsr04 import HCSR04 import wave print('{}: telnet is {} on {}'.format(*network.telnet.status())) sensor = HCSR04(14, 12) dac = DAC(26) dac.write(0) #dac=None t = TouchPad(13) t.config(500) feedback = ADC(32) feedback.atten(ADC.ATTN_11DB) feedback.read() / 4095 vbat = ADC(35) vbat.atten(ADC.ATTN_11DB) print("battery is at {} Volts".format(vbat.read() / 4095 * 3.9 * 2)) timer = Timer(0)
from machine import DAC, Pin da1 = DAC(Pin(26, Pin.OUT), bits=8) value = 2 da1.write(int(value * 255 / 3.3))
from machine import Pin, ADC, DAC import time adc = ADC() p_input = adc.channel(pin="P14", attn=ADC.ATTN_11DB) # analog input p_output = DAC("P22") # analog output while True: time.sleep(.5) print(p_input() / 4095) p_output.write(p_input() / 4095)
from machine import DAC, Pin dac = DAC(Pin(25)) dac.write(128)
#ADC & DAC basic from pin_map import * from machine import ADC, DAC import time dac = DAC(GPIO25) dac.write(0.5) print("DAC output activating...") adc = ADC() apin = adc.channel(pin=GPIO39, attn=ADC.ATTN_11DB) #ADC.ATTN_0DB : x1.00 #ADC.ATTN_5DB : x1.78 #ADC.ATTN_6DB : x2.00 #ADC.ATTN_11DB : x3.55 for i in range(10): val = apin.value() volt = apin.voltage() print("ADC input value : %d, %d[mV]" % (val, volt)) time.sleep(1)
from machine import Pin, DAC from time import sleep dac = DAC(Pin(26)) print("Running a triangular wave form with a frequency of ~ 1 Hz on pin 26") while True: dac.write(0) sleep(2) dac.write(255) sleep(2)
# Probleme saturation ADC. # Solution DAC comme tension de charge !!! from machine import ADC, DAC, Pin from time import sleep_ms pinE = DAC(Pin(25)) adc = ADC(Pin(35)) #adc.atten(ADC.ATTN_11DB) #adc.width(ADC.WIDTH_12BIT) pinE.write(75) for i in range(100): N = adc.read() print(i, ";", N) sleep_ms(2) pinE.write(0) # 10 bit > 975 # 12 bit > 3900 #adc.deinit()